github.com/polarismesh/polaris@v1.17.8/store/mock/api_mock.go

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

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

import (
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	model "github.com/polarismesh/polaris/common/model"
	store "github.com/polarismesh/polaris/store"
)

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// ActiveConfigFileReleaseTx mocks base method.
func (m *MockStore) ActiveConfigFileReleaseTx(tx store.Tx, release *model.ConfigFileRelease) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActiveConfigFileReleaseTx", tx, release)
	ret0, _ := ret[0].(error)
	return ret0
}

// ActiveConfigFileReleaseTx indicates an expected call of ActiveConfigFileReleaseTx.
func (mr *MockStoreMockRecorder) ActiveConfigFileReleaseTx(tx, release interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActiveConfigFileReleaseTx", reflect.TypeOf((*MockStore)(nil).ActiveConfigFileReleaseTx), tx, release)
}

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

// AddGroup indicates an expected call of AddGroup.
func (mr *MockStoreMockRecorder) AddGroup(group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGroup", reflect.TypeOf((*MockStore)(nil).AddGroup), group)
}

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

// AddInstance indicates an expected call of AddInstance.
func (mr *MockStoreMockRecorder) AddInstance(instance interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddInstance", reflect.TypeOf((*MockStore)(nil).AddInstance), instance)
}

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

// AddNamespace indicates an expected call of AddNamespace.
func (mr *MockStoreMockRecorder) AddNamespace(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNamespace", reflect.TypeOf((*MockStore)(nil).AddNamespace), namespace)
}

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

// AddService indicates an expected call of AddService.
func (mr *MockStoreMockRecorder) AddService(service interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddService", reflect.TypeOf((*MockStore)(nil).AddService), service)
}

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

// AddStrategy indicates an expected call of AddStrategy.
func (mr *MockStoreMockRecorder) AddStrategy(strategy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStrategy", reflect.TypeOf((*MockStore)(nil).AddStrategy), strategy)
}

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

// AddUser indicates an expected call of AddUser.
func (mr *MockStoreMockRecorder) AddUser(user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUser", reflect.TypeOf((*MockStore)(nil).AddUser), user)
}

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

// BatchAddClients indicates an expected call of BatchAddClients.
func (mr *MockStoreMockRecorder) BatchAddClients(clients interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchAddClients", reflect.TypeOf((*MockStore)(nil).BatchAddClients), clients)
}

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

// BatchAddInstances indicates an expected call of BatchAddInstances.
func (mr *MockStoreMockRecorder) BatchAddInstances(instances interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchAddInstances", reflect.TypeOf((*MockStore)(nil).BatchAddInstances), instances)
}

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

// BatchAppendInstanceMetadata indicates an expected call of BatchAppendInstanceMetadata.
func (mr *MockStoreMockRecorder) BatchAppendInstanceMetadata(requests interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchAppendInstanceMetadata", reflect.TypeOf((*MockStore)(nil).BatchAppendInstanceMetadata), requests)
}

// BatchCleanDeletedClients mocks base method.
func (m *MockStore) BatchCleanDeletedClients(timeout time.Duration, batchSize uint32) (uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCleanDeletedClients", timeout, batchSize)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchCleanDeletedClients indicates an expected call of BatchCleanDeletedClients.
func (mr *MockStoreMockRecorder) BatchCleanDeletedClients(timeout, batchSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCleanDeletedClients", reflect.TypeOf((*MockStore)(nil).BatchCleanDeletedClients), timeout, batchSize)
}

// BatchCleanDeletedInstances mocks base method.
func (m *MockStore) BatchCleanDeletedInstances(timeout time.Duration, batchSize uint32) (uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCleanDeletedInstances", timeout, batchSize)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchCleanDeletedInstances indicates an expected call of BatchCleanDeletedInstances.
func (mr *MockStoreMockRecorder) BatchCleanDeletedInstances(timeout, batchSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCleanDeletedInstances", reflect.TypeOf((*MockStore)(nil).BatchCleanDeletedInstances), timeout, batchSize)
}

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

// BatchDeleteClients indicates an expected call of BatchDeleteClients.
func (mr *MockStoreMockRecorder) BatchDeleteClients(ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteClients", reflect.TypeOf((*MockStore)(nil).BatchDeleteClients), ids)
}

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

// BatchDeleteInstances indicates an expected call of BatchDeleteInstances.
func (mr *MockStoreMockRecorder) BatchDeleteInstances(ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteInstances", reflect.TypeOf((*MockStore)(nil).BatchDeleteInstances), ids)
}

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

// BatchGetInstanceIsolate indicates an expected call of BatchGetInstanceIsolate.
func (mr *MockStoreMockRecorder) BatchGetInstanceIsolate(ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetInstanceIsolate", reflect.TypeOf((*MockStore)(nil).BatchGetInstanceIsolate), ids)
}

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

// BatchRemoveInstanceMetadata indicates an expected call of BatchRemoveInstanceMetadata.
func (mr *MockStoreMockRecorder) BatchRemoveInstanceMetadata(requests interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchRemoveInstanceMetadata", reflect.TypeOf((*MockStore)(nil).BatchRemoveInstanceMetadata), requests)
}

// BatchSetInstanceHealthStatus mocks base method.
func (m *MockStore) BatchSetInstanceHealthStatus(ids []interface{}, healthy int, revision string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchSetInstanceHealthStatus", ids, healthy, revision)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchSetInstanceHealthStatus indicates an expected call of BatchSetInstanceHealthStatus.
func (mr *MockStoreMockRecorder) BatchSetInstanceHealthStatus(ids, healthy, revision interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchSetInstanceHealthStatus", reflect.TypeOf((*MockStore)(nil).BatchSetInstanceHealthStatus), ids, healthy, revision)
}

// BatchSetInstanceIsolate mocks base method.
func (m *MockStore) BatchSetInstanceIsolate(ids []interface{}, isolate int, revision string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchSetInstanceIsolate", ids, isolate, revision)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchSetInstanceIsolate indicates an expected call of BatchSetInstanceIsolate.
func (mr *MockStoreMockRecorder) BatchSetInstanceIsolate(ids, isolate, revision interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchSetInstanceIsolate", reflect.TypeOf((*MockStore)(nil).BatchSetInstanceIsolate), ids, isolate, revision)
}

// CleanConfigFileReleaseHistory mocks base method.
func (m *MockStore) CleanConfigFileReleaseHistory(endTime time.Time, limit uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanConfigFileReleaseHistory", endTime, limit)
	ret0, _ := ret[0].(error)
	return ret0
}

// CleanConfigFileReleaseHistory indicates an expected call of CleanConfigFileReleaseHistory.
func (mr *MockStoreMockRecorder) CleanConfigFileReleaseHistory(endTime, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanConfigFileReleaseHistory", reflect.TypeOf((*MockStore)(nil).CleanConfigFileReleaseHistory), endTime, limit)
}

// CleanConfigFileReleasesTx mocks base method.
func (m *MockStore) CleanConfigFileReleasesTx(tx store.Tx, namespace, group, fileName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanConfigFileReleasesTx", tx, namespace, group, fileName)
	ret0, _ := ret[0].(error)
	return ret0
}

// CleanConfigFileReleasesTx indicates an expected call of CleanConfigFileReleasesTx.
func (mr *MockStoreMockRecorder) CleanConfigFileReleasesTx(tx, namespace, group, fileName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanConfigFileReleasesTx", reflect.TypeOf((*MockStore)(nil).CleanConfigFileReleasesTx), tx, namespace, group, fileName)
}

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

// CleanInstance indicates an expected call of CleanInstance.
func (mr *MockStoreMockRecorder) CleanInstance(instanceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanInstance", reflect.TypeOf((*MockStore)(nil).CleanInstance), instanceID)
}

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

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

// CountConfigFiles mocks base method.
func (m *MockStore) CountConfigFiles(namespace, group string) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountConfigFiles", namespace, group)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountConfigFiles indicates an expected call of CountConfigFiles.
func (mr *MockStoreMockRecorder) CountConfigFiles(namespace, group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountConfigFiles", reflect.TypeOf((*MockStore)(nil).CountConfigFiles), namespace, group)
}

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

// CountConfigGroups indicates an expected call of CountConfigGroups.
func (mr *MockStoreMockRecorder) CountConfigGroups(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountConfigGroups", reflect.TypeOf((*MockStore)(nil).CountConfigGroups), namespace)
}

// CountConfigReleases mocks base method.
func (m *MockStore) CountConfigReleases(namespace, group string, onlyActive bool) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountConfigReleases", namespace, group, onlyActive)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountConfigReleases indicates an expected call of CountConfigReleases.
func (mr *MockStoreMockRecorder) CountConfigReleases(namespace, group, onlyActive interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountConfigReleases", reflect.TypeOf((*MockStore)(nil).CountConfigReleases), namespace, group, onlyActive)
}

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

// CreateCircuitBreakerRule indicates an expected call of CreateCircuitBreakerRule.
func (mr *MockStoreMockRecorder) CreateCircuitBreakerRule(cbRule interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCircuitBreakerRule", reflect.TypeOf((*MockStore)(nil).CreateCircuitBreakerRule), cbRule)
}

// CreateConfigFileGroup mocks base method.
func (m *MockStore) CreateConfigFileGroup(fileGroup *model.ConfigFileGroup) (*model.ConfigFileGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConfigFileGroup", fileGroup)
	ret0, _ := ret[0].(*model.ConfigFileGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateConfigFileGroup indicates an expected call of CreateConfigFileGroup.
func (mr *MockStoreMockRecorder) CreateConfigFileGroup(fileGroup interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigFileGroup", reflect.TypeOf((*MockStore)(nil).CreateConfigFileGroup), fileGroup)
}

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

// CreateConfigFileReleaseHistory indicates an expected call of CreateConfigFileReleaseHistory.
func (mr *MockStoreMockRecorder) CreateConfigFileReleaseHistory(history interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigFileReleaseHistory", reflect.TypeOf((*MockStore)(nil).CreateConfigFileReleaseHistory), history)
}

// CreateConfigFileReleaseTx mocks base method.
func (m *MockStore) CreateConfigFileReleaseTx(tx store.Tx, fileRelease *model.ConfigFileRelease) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConfigFileReleaseTx", tx, fileRelease)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateConfigFileReleaseTx indicates an expected call of CreateConfigFileReleaseTx.
func (mr *MockStoreMockRecorder) CreateConfigFileReleaseTx(tx, fileRelease interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigFileReleaseTx", reflect.TypeOf((*MockStore)(nil).CreateConfigFileReleaseTx), tx, fileRelease)
}

// CreateConfigFileTemplate mocks base method.
func (m *MockStore) CreateConfigFileTemplate(template *model.ConfigFileTemplate) (*model.ConfigFileTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConfigFileTemplate", template)
	ret0, _ := ret[0].(*model.ConfigFileTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateConfigFileTemplate indicates an expected call of CreateConfigFileTemplate.
func (mr *MockStoreMockRecorder) CreateConfigFileTemplate(template interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigFileTemplate", reflect.TypeOf((*MockStore)(nil).CreateConfigFileTemplate), template)
}

// CreateConfigFileTx mocks base method.
func (m *MockStore) CreateConfigFileTx(tx store.Tx, file *model.ConfigFile) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConfigFileTx", tx, file)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateConfigFileTx indicates an expected call of CreateConfigFileTx.
func (mr *MockStoreMockRecorder) CreateConfigFileTx(tx, file interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigFileTx", reflect.TypeOf((*MockStore)(nil).CreateConfigFileTx), tx, file)
}

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

// CreateFaultDetectRule indicates an expected call of CreateFaultDetectRule.
func (mr *MockStoreMockRecorder) CreateFaultDetectRule(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFaultDetectRule", reflect.TypeOf((*MockStore)(nil).CreateFaultDetectRule), conf)
}

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

// CreateRateLimit indicates an expected call of CreateRateLimit.
func (mr *MockStoreMockRecorder) CreateRateLimit(limiting interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRateLimit", reflect.TypeOf((*MockStore)(nil).CreateRateLimit), limiting)
}

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

// CreateRoutingConfig indicates an expected call of CreateRoutingConfig.
func (mr *MockStoreMockRecorder) CreateRoutingConfig(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoutingConfig", reflect.TypeOf((*MockStore)(nil).CreateRoutingConfig), conf)
}

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

// CreateRoutingConfigV2 indicates an expected call of CreateRoutingConfigV2.
func (mr *MockStoreMockRecorder) CreateRoutingConfigV2(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoutingConfigV2", reflect.TypeOf((*MockStore)(nil).CreateRoutingConfigV2), conf)
}

// CreateRoutingConfigV2Tx mocks base method.
func (m *MockStore) CreateRoutingConfigV2Tx(tx store.Tx, conf *model.RouterConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRoutingConfigV2Tx", tx, conf)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateRoutingConfigV2Tx indicates an expected call of CreateRoutingConfigV2Tx.
func (mr *MockStoreMockRecorder) CreateRoutingConfigV2Tx(tx, conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoutingConfigV2Tx", reflect.TypeOf((*MockStore)(nil).CreateRoutingConfigV2Tx), tx, conf)
}

// CreateTransaction mocks base method.
func (m *MockStore) CreateTransaction() (store.Transaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTransaction")
	ret0, _ := ret[0].(store.Transaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// DeleteCircuitBreakerRule indicates an expected call of DeleteCircuitBreakerRule.
func (mr *MockStoreMockRecorder) DeleteCircuitBreakerRule(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCircuitBreakerRule", reflect.TypeOf((*MockStore)(nil).DeleteCircuitBreakerRule), id)
}

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

// DeleteConfigFileGroup indicates an expected call of DeleteConfigFileGroup.
func (mr *MockStoreMockRecorder) DeleteConfigFileGroup(namespace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigFileGroup", reflect.TypeOf((*MockStore)(nil).DeleteConfigFileGroup), namespace, name)
}

// DeleteConfigFileReleaseTx mocks base method.
func (m *MockStore) DeleteConfigFileReleaseTx(tx store.Tx, data *model.ConfigFileReleaseKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteConfigFileReleaseTx", tx, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteConfigFileReleaseTx indicates an expected call of DeleteConfigFileReleaseTx.
func (mr *MockStoreMockRecorder) DeleteConfigFileReleaseTx(tx, data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigFileReleaseTx", reflect.TypeOf((*MockStore)(nil).DeleteConfigFileReleaseTx), tx, data)
}

// DeleteConfigFileTx mocks base method.
func (m *MockStore) DeleteConfigFileTx(tx store.Tx, namespace, group, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteConfigFileTx", tx, namespace, group, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteConfigFileTx indicates an expected call of DeleteConfigFileTx.
func (mr *MockStoreMockRecorder) DeleteConfigFileTx(tx, namespace, group, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigFileTx", reflect.TypeOf((*MockStore)(nil).DeleteConfigFileTx), tx, namespace, group, name)
}

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

// DeleteFaultDetectRule indicates an expected call of DeleteFaultDetectRule.
func (mr *MockStoreMockRecorder) DeleteFaultDetectRule(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFaultDetectRule", reflect.TypeOf((*MockStore)(nil).DeleteFaultDetectRule), id)
}

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

// DeleteGroup indicates an expected call of DeleteGroup.
func (mr *MockStoreMockRecorder) DeleteGroup(group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroup", reflect.TypeOf((*MockStore)(nil).DeleteGroup), group)
}

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

// DeleteInstance indicates an expected call of DeleteInstance.
func (mr *MockStoreMockRecorder) DeleteInstance(instanceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstance", reflect.TypeOf((*MockStore)(nil).DeleteInstance), instanceID)
}

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

// DeleteRateLimit indicates an expected call of DeleteRateLimit.
func (mr *MockStoreMockRecorder) DeleteRateLimit(limiting interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRateLimit", reflect.TypeOf((*MockStore)(nil).DeleteRateLimit), limiting)
}

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

// DeleteRoutingConfig indicates an expected call of DeleteRoutingConfig.
func (mr *MockStoreMockRecorder) DeleteRoutingConfig(serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoutingConfig", reflect.TypeOf((*MockStore)(nil).DeleteRoutingConfig), serviceID)
}

// DeleteRoutingConfigTx mocks base method.
func (m *MockStore) DeleteRoutingConfigTx(tx store.Tx, serviceID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoutingConfigTx", tx, serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRoutingConfigTx indicates an expected call of DeleteRoutingConfigTx.
func (mr *MockStoreMockRecorder) DeleteRoutingConfigTx(tx, serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoutingConfigTx", reflect.TypeOf((*MockStore)(nil).DeleteRoutingConfigTx), tx, serviceID)
}

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

// DeleteRoutingConfigV2 indicates an expected call of DeleteRoutingConfigV2.
func (mr *MockStoreMockRecorder) DeleteRoutingConfigV2(serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoutingConfigV2", reflect.TypeOf((*MockStore)(nil).DeleteRoutingConfigV2), serviceID)
}

// DeleteService mocks base method.
func (m *MockStore) DeleteService(id, serviceName, namespaceName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteService", id, serviceName, namespaceName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteService indicates an expected call of DeleteService.
func (mr *MockStoreMockRecorder) DeleteService(id, serviceName, namespaceName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MockStore)(nil).DeleteService), id, serviceName, namespaceName)
}

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

// DeleteServiceAlias indicates an expected call of DeleteServiceAlias.
func (mr *MockStoreMockRecorder) DeleteServiceAlias(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceAlias", reflect.TypeOf((*MockStore)(nil).DeleteServiceAlias), name, namespace)
}

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

// DeleteStrategy indicates an expected call of DeleteStrategy.
func (mr *MockStoreMockRecorder) DeleteStrategy(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStrategy", reflect.TypeOf((*MockStore)(nil).DeleteStrategy), id)
}

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

// DeleteUser indicates an expected call of DeleteUser.
func (mr *MockStoreMockRecorder) DeleteUser(user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockStore)(nil).DeleteUser), user)
}

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

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

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

// EnableCircuitBreakerRule indicates an expected call of EnableCircuitBreakerRule.
func (mr *MockStoreMockRecorder) EnableCircuitBreakerRule(cbRule interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableCircuitBreakerRule", reflect.TypeOf((*MockStore)(nil).EnableCircuitBreakerRule), cbRule)
}

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

// EnableRateLimit indicates an expected call of EnableRateLimit.
func (mr *MockStoreMockRecorder) EnableRateLimit(limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRateLimit", reflect.TypeOf((*MockStore)(nil).EnableRateLimit), limit)
}

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

// EnableRouting indicates an expected call of EnableRouting.
func (mr *MockStoreMockRecorder) EnableRouting(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRouting", reflect.TypeOf((*MockStore)(nil).EnableRouting), conf)
}

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

// GenNextL5Sid indicates an expected call of GenNextL5Sid.
func (mr *MockStoreMockRecorder) GenNextL5Sid(layoutID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenNextL5Sid", reflect.TypeOf((*MockStore)(nil).GenNextL5Sid), layoutID)
}

// GetCircuitBreakerRules mocks base method.
func (m *MockStore) GetCircuitBreakerRules(filter map[string]string, offset, limit uint32) (uint32, []*model.CircuitBreakerRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCircuitBreakerRules", filter, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.CircuitBreakerRule)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCircuitBreakerRules indicates an expected call of GetCircuitBreakerRules.
func (mr *MockStoreMockRecorder) GetCircuitBreakerRules(filter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCircuitBreakerRules", reflect.TypeOf((*MockStore)(nil).GetCircuitBreakerRules), filter, offset, limit)
}

// GetCircuitBreakerRulesForCache mocks base method.
func (m *MockStore) GetCircuitBreakerRulesForCache(mtime time.Time, firstUpdate bool) ([]*model.CircuitBreakerRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCircuitBreakerRulesForCache", mtime, firstUpdate)
	ret0, _ := ret[0].([]*model.CircuitBreakerRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCircuitBreakerRulesForCache indicates an expected call of GetCircuitBreakerRulesForCache.
func (mr *MockStoreMockRecorder) GetCircuitBreakerRulesForCache(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCircuitBreakerRulesForCache", reflect.TypeOf((*MockStore)(nil).GetCircuitBreakerRulesForCache), mtime, firstUpdate)
}

// GetConfigFile mocks base method.
func (m *MockStore) GetConfigFile(namespace, group, name string) (*model.ConfigFile, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigFile", namespace, group, name)
	ret0, _ := ret[0].(*model.ConfigFile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigFile indicates an expected call of GetConfigFile.
func (mr *MockStoreMockRecorder) GetConfigFile(namespace, group, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigFile", reflect.TypeOf((*MockStore)(nil).GetConfigFile), namespace, group, name)
}

// GetConfigFileActiveRelease mocks base method.
func (m *MockStore) GetConfigFileActiveRelease(file *model.ConfigFileKey) (*model.ConfigFileRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigFileActiveRelease", file)
	ret0, _ := ret[0].(*model.ConfigFileRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigFileActiveRelease indicates an expected call of GetConfigFileActiveRelease.
func (mr *MockStoreMockRecorder) GetConfigFileActiveRelease(file interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigFileActiveRelease", reflect.TypeOf((*MockStore)(nil).GetConfigFileActiveRelease), file)
}

// GetConfigFileActiveReleaseTx mocks base method.
func (m *MockStore) GetConfigFileActiveReleaseTx(tx store.Tx, file *model.ConfigFileKey) (*model.ConfigFileRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigFileActiveReleaseTx", tx, file)
	ret0, _ := ret[0].(*model.ConfigFileRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigFileActiveReleaseTx indicates an expected call of GetConfigFileActiveReleaseTx.
func (mr *MockStoreMockRecorder) GetConfigFileActiveReleaseTx(tx, file interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigFileActiveReleaseTx", reflect.TypeOf((*MockStore)(nil).GetConfigFileActiveReleaseTx), tx, file)
}

// GetConfigFileGroup mocks base method.
func (m *MockStore) GetConfigFileGroup(namespace, name string) (*model.ConfigFileGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigFileGroup", namespace, name)
	ret0, _ := ret[0].(*model.ConfigFileGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigFileGroup indicates an expected call of GetConfigFileGroup.
func (mr *MockStoreMockRecorder) GetConfigFileGroup(namespace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigFileGroup", reflect.TypeOf((*MockStore)(nil).GetConfigFileGroup), namespace, name)
}

// GetConfigFileRelease mocks base method.
func (m *MockStore) GetConfigFileRelease(req *model.ConfigFileReleaseKey) (*model.ConfigFileRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigFileRelease", req)
	ret0, _ := ret[0].(*model.ConfigFileRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigFileRelease indicates an expected call of GetConfigFileRelease.
func (mr *MockStoreMockRecorder) GetConfigFileRelease(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigFileRelease", reflect.TypeOf((*MockStore)(nil).GetConfigFileRelease), req)
}

// GetConfigFileReleaseTx mocks base method.
func (m *MockStore) GetConfigFileReleaseTx(tx store.Tx, req *model.ConfigFileReleaseKey) (*model.ConfigFileRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigFileReleaseTx", tx, req)
	ret0, _ := ret[0].(*model.ConfigFileRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigFileReleaseTx indicates an expected call of GetConfigFileReleaseTx.
func (mr *MockStoreMockRecorder) GetConfigFileReleaseTx(tx, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigFileReleaseTx", reflect.TypeOf((*MockStore)(nil).GetConfigFileReleaseTx), tx, req)
}

// GetConfigFileTemplate mocks base method.
func (m *MockStore) GetConfigFileTemplate(name string) (*model.ConfigFileTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigFileTemplate", name)
	ret0, _ := ret[0].(*model.ConfigFileTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigFileTemplate indicates an expected call of GetConfigFileTemplate.
func (mr *MockStoreMockRecorder) GetConfigFileTemplate(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigFileTemplate", reflect.TypeOf((*MockStore)(nil).GetConfigFileTemplate), name)
}

// GetConfigFileTx mocks base method.
func (m *MockStore) GetConfigFileTx(tx store.Tx, namespace, group, name string) (*model.ConfigFile, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigFileTx", tx, namespace, group, name)
	ret0, _ := ret[0].(*model.ConfigFile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigFileTx indicates an expected call of GetConfigFileTx.
func (mr *MockStoreMockRecorder) GetConfigFileTx(tx, namespace, group, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigFileTx", reflect.TypeOf((*MockStore)(nil).GetConfigFileTx), tx, namespace, group, name)
}

// GetDefaultStrategyDetailByPrincipal mocks base method.
func (m *MockStore) GetDefaultStrategyDetailByPrincipal(principalId string, principalType model.PrincipalType) (*model.StrategyDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultStrategyDetailByPrincipal", principalId, principalType)
	ret0, _ := ret[0].(*model.StrategyDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultStrategyDetailByPrincipal indicates an expected call of GetDefaultStrategyDetailByPrincipal.
func (mr *MockStoreMockRecorder) GetDefaultStrategyDetailByPrincipal(principalId, principalType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultStrategyDetailByPrincipal", reflect.TypeOf((*MockStore)(nil).GetDefaultStrategyDetailByPrincipal), principalId, principalType)
}

// GetExpandInstances mocks base method.
func (m *MockStore) GetExpandInstances(filter, metaFilter map[string]string, offset, limit uint32) (uint32, []*model.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExpandInstances", filter, metaFilter, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.Instance)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetExpandInstances indicates an expected call of GetExpandInstances.
func (mr *MockStoreMockRecorder) GetExpandInstances(filter, metaFilter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExpandInstances", reflect.TypeOf((*MockStore)(nil).GetExpandInstances), filter, metaFilter, offset, limit)
}

// GetExtendRateLimits mocks base method.
func (m *MockStore) GetExtendRateLimits(query map[string]string, offset, limit uint32) (uint32, []*model.ExtendRateLimit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExtendRateLimits", query, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.ExtendRateLimit)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetExtendRateLimits indicates an expected call of GetExtendRateLimits.
func (mr *MockStoreMockRecorder) GetExtendRateLimits(query, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExtendRateLimits", reflect.TypeOf((*MockStore)(nil).GetExtendRateLimits), query, offset, limit)
}

// GetFaultDetectRules mocks base method.
func (m *MockStore) GetFaultDetectRules(filter map[string]string, offset, limit uint32) (uint32, []*model.FaultDetectRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFaultDetectRules", filter, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.FaultDetectRule)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetFaultDetectRules indicates an expected call of GetFaultDetectRules.
func (mr *MockStoreMockRecorder) GetFaultDetectRules(filter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFaultDetectRules", reflect.TypeOf((*MockStore)(nil).GetFaultDetectRules), filter, offset, limit)
}

// GetFaultDetectRulesForCache mocks base method.
func (m *MockStore) GetFaultDetectRulesForCache(mtime time.Time, firstUpdate bool) ([]*model.FaultDetectRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFaultDetectRulesForCache", mtime, firstUpdate)
	ret0, _ := ret[0].([]*model.FaultDetectRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFaultDetectRulesForCache indicates an expected call of GetFaultDetectRulesForCache.
func (mr *MockStoreMockRecorder) GetFaultDetectRulesForCache(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFaultDetectRulesForCache", reflect.TypeOf((*MockStore)(nil).GetFaultDetectRulesForCache), mtime, firstUpdate)
}

// GetGroup mocks base method.
func (m *MockStore) GetGroup(id string) (*model.UserGroupDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroup", id)
	ret0, _ := ret[0].(*model.UserGroupDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroup indicates an expected call of GetGroup.
func (mr *MockStoreMockRecorder) GetGroup(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroup", reflect.TypeOf((*MockStore)(nil).GetGroup), id)
}

// GetGroupByName mocks base method.
func (m *MockStore) GetGroupByName(name, owner string) (*model.UserGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupByName", name, owner)
	ret0, _ := ret[0].(*model.UserGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupByName indicates an expected call of GetGroupByName.
func (mr *MockStoreMockRecorder) GetGroupByName(name, owner interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupByName", reflect.TypeOf((*MockStore)(nil).GetGroupByName), name, owner)
}

// GetGroups mocks base method.
func (m *MockStore) GetGroups(filters map[string]string, offset, limit uint32) (uint32, []*model.UserGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroups", filters, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.UserGroup)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGroups indicates an expected call of GetGroups.
func (mr *MockStoreMockRecorder) GetGroups(filters, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroups", reflect.TypeOf((*MockStore)(nil).GetGroups), filters, offset, limit)
}

// GetGroupsForCache mocks base method.
func (m *MockStore) GetGroupsForCache(mtime time.Time, firstUpdate bool) ([]*model.UserGroupDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupsForCache", mtime, firstUpdate)
	ret0, _ := ret[0].([]*model.UserGroupDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupsForCache indicates an expected call of GetGroupsForCache.
func (mr *MockStoreMockRecorder) GetGroupsForCache(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCache", reflect.TypeOf((*MockStore)(nil).GetGroupsForCache), mtime, firstUpdate)
}

// GetInstance mocks base method.
func (m *MockStore) GetInstance(instanceID string) (*model.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstance", instanceID)
	ret0, _ := ret[0].(*model.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstance indicates an expected call of GetInstance.
func (mr *MockStoreMockRecorder) GetInstance(instanceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstance", reflect.TypeOf((*MockStore)(nil).GetInstance), instanceID)
}

// GetInstancesBrief mocks base method.
func (m *MockStore) GetInstancesBrief(ids map[string]bool) (map[string]*model.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstancesBrief", ids)
	ret0, _ := ret[0].(map[string]*model.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstancesBrief indicates an expected call of GetInstancesBrief.
func (mr *MockStoreMockRecorder) GetInstancesBrief(ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesBrief", reflect.TypeOf((*MockStore)(nil).GetInstancesBrief), ids)
}

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

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

// GetInstancesCountTx mocks base method.
func (m *MockStore) GetInstancesCountTx(tx store.Tx) (uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstancesCountTx", tx)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstancesCountTx indicates an expected call of GetInstancesCountTx.
func (mr *MockStoreMockRecorder) GetInstancesCountTx(tx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesCountTx", reflect.TypeOf((*MockStore)(nil).GetInstancesCountTx), tx)
}

// GetInstancesMainByService mocks base method.
func (m *MockStore) GetInstancesMainByService(serviceID, host string) ([]*model.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstancesMainByService", serviceID, host)
	ret0, _ := ret[0].([]*model.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstancesMainByService indicates an expected call of GetInstancesMainByService.
func (mr *MockStoreMockRecorder) GetInstancesMainByService(serviceID, host interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesMainByService", reflect.TypeOf((*MockStore)(nil).GetInstancesMainByService), serviceID, host)
}

// GetL5Extend mocks base method.
func (m *MockStore) GetL5Extend(serviceID string) (map[string]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetL5Extend", serviceID)
	ret0, _ := ret[0].(map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetL5Extend indicates an expected call of GetL5Extend.
func (mr *MockStoreMockRecorder) GetL5Extend(serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetL5Extend", reflect.TypeOf((*MockStore)(nil).GetL5Extend), serviceID)
}

// GetMoreClients mocks base method.
func (m *MockStore) GetMoreClients(mtime time.Time, firstUpdate bool) (map[string]*model.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreClients", mtime, firstUpdate)
	ret0, _ := ret[0].(map[string]*model.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreClients indicates an expected call of GetMoreClients.
func (mr *MockStoreMockRecorder) GetMoreClients(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreClients", reflect.TypeOf((*MockStore)(nil).GetMoreClients), mtime, firstUpdate)
}

// GetMoreConfigGroup mocks base method.
func (m *MockStore) GetMoreConfigGroup(firstUpdate bool, mtime time.Time) ([]*model.ConfigFileGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreConfigGroup", firstUpdate, mtime)
	ret0, _ := ret[0].([]*model.ConfigFileGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreConfigGroup indicates an expected call of GetMoreConfigGroup.
func (mr *MockStoreMockRecorder) GetMoreConfigGroup(firstUpdate, mtime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreConfigGroup", reflect.TypeOf((*MockStore)(nil).GetMoreConfigGroup), firstUpdate, mtime)
}

// GetMoreInstances mocks base method.
func (m *MockStore) GetMoreInstances(tx store.Tx, mtime time.Time, firstUpdate, needMeta bool, serviceID []string) (map[string]*model.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreInstances", tx, mtime, firstUpdate, needMeta, serviceID)
	ret0, _ := ret[0].(map[string]*model.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreInstances indicates an expected call of GetMoreInstances.
func (mr *MockStoreMockRecorder) GetMoreInstances(tx, mtime, firstUpdate, needMeta, serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreInstances", reflect.TypeOf((*MockStore)(nil).GetMoreInstances), tx, mtime, firstUpdate, needMeta, serviceID)
}

// GetMoreL5Extend mocks base method.
func (m *MockStore) GetMoreL5Extend(mtime time.Time) (map[string]map[string]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreL5Extend", mtime)
	ret0, _ := ret[0].(map[string]map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreL5Extend indicates an expected call of GetMoreL5Extend.
func (mr *MockStoreMockRecorder) GetMoreL5Extend(mtime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreL5Extend", reflect.TypeOf((*MockStore)(nil).GetMoreL5Extend), mtime)
}

// GetMoreL5IPConfigs mocks base method.
func (m *MockStore) GetMoreL5IPConfigs(flow uint32) ([]*model.IPConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreL5IPConfigs", flow)
	ret0, _ := ret[0].([]*model.IPConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreL5IPConfigs indicates an expected call of GetMoreL5IPConfigs.
func (mr *MockStoreMockRecorder) GetMoreL5IPConfigs(flow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreL5IPConfigs", reflect.TypeOf((*MockStore)(nil).GetMoreL5IPConfigs), flow)
}

// GetMoreL5Policies mocks base method.
func (m *MockStore) GetMoreL5Policies(flow uint32) ([]*model.Policy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreL5Policies", flow)
	ret0, _ := ret[0].([]*model.Policy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreL5Policies indicates an expected call of GetMoreL5Policies.
func (mr *MockStoreMockRecorder) GetMoreL5Policies(flow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreL5Policies", reflect.TypeOf((*MockStore)(nil).GetMoreL5Policies), flow)
}

// GetMoreL5Routes mocks base method.
func (m *MockStore) GetMoreL5Routes(flow uint32) ([]*model.Route, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreL5Routes", flow)
	ret0, _ := ret[0].([]*model.Route)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreL5Routes indicates an expected call of GetMoreL5Routes.
func (mr *MockStoreMockRecorder) GetMoreL5Routes(flow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreL5Routes", reflect.TypeOf((*MockStore)(nil).GetMoreL5Routes), flow)
}

// GetMoreL5Sections mocks base method.
func (m *MockStore) GetMoreL5Sections(flow uint32) ([]*model.Section, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreL5Sections", flow)
	ret0, _ := ret[0].([]*model.Section)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreL5Sections indicates an expected call of GetMoreL5Sections.
func (mr *MockStoreMockRecorder) GetMoreL5Sections(flow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreL5Sections", reflect.TypeOf((*MockStore)(nil).GetMoreL5Sections), flow)
}

// GetMoreNamespaces mocks base method.
func (m *MockStore) GetMoreNamespaces(mtime time.Time) ([]*model.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreNamespaces", mtime)
	ret0, _ := ret[0].([]*model.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreNamespaces indicates an expected call of GetMoreNamespaces.
func (mr *MockStoreMockRecorder) GetMoreNamespaces(mtime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreNamespaces", reflect.TypeOf((*MockStore)(nil).GetMoreNamespaces), mtime)
}

// GetMoreReleaseFile mocks base method.
func (m *MockStore) GetMoreReleaseFile(firstUpdate bool, modifyTime time.Time) ([]*model.ConfigFileRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreReleaseFile", firstUpdate, modifyTime)
	ret0, _ := ret[0].([]*model.ConfigFileRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreReleaseFile indicates an expected call of GetMoreReleaseFile.
func (mr *MockStoreMockRecorder) GetMoreReleaseFile(firstUpdate, modifyTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreReleaseFile", reflect.TypeOf((*MockStore)(nil).GetMoreReleaseFile), firstUpdate, modifyTime)
}

// GetMoreServices mocks base method.
func (m *MockStore) GetMoreServices(mtime time.Time, firstUpdate, disableBusiness, needMeta bool) (map[string]*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreServices", mtime, firstUpdate, disableBusiness, needMeta)
	ret0, _ := ret[0].(map[string]*model.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreServices indicates an expected call of GetMoreServices.
func (mr *MockStoreMockRecorder) GetMoreServices(mtime, firstUpdate, disableBusiness, needMeta interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreServices", reflect.TypeOf((*MockStore)(nil).GetMoreServices), mtime, firstUpdate, disableBusiness, needMeta)
}

// GetNamespace mocks base method.
func (m *MockStore) GetNamespace(name string) (*model.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", name)
	ret0, _ := ret[0].(*model.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespace indicates an expected call of GetNamespace.
func (mr *MockStoreMockRecorder) GetNamespace(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockStore)(nil).GetNamespace), name)
}

// GetNamespaces mocks base method.
func (m *MockStore) GetNamespaces(filter map[string][]string, offset, limit int) ([]*model.Namespace, uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaces", filter, offset, limit)
	ret0, _ := ret[0].([]*model.Namespace)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetNamespaces indicates an expected call of GetNamespaces.
func (mr *MockStoreMockRecorder) GetNamespaces(filter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaces", reflect.TypeOf((*MockStore)(nil).GetNamespaces), filter, offset, limit)
}

// GetRateLimitWithID mocks base method.
func (m *MockStore) GetRateLimitWithID(id string) (*model.RateLimit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRateLimitWithID", id)
	ret0, _ := ret[0].(*model.RateLimit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRateLimitWithID indicates an expected call of GetRateLimitWithID.
func (mr *MockStoreMockRecorder) GetRateLimitWithID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimitWithID", reflect.TypeOf((*MockStore)(nil).GetRateLimitWithID), id)
}

// GetRateLimitsForCache mocks base method.
func (m *MockStore) GetRateLimitsForCache(mtime time.Time, firstUpdate bool) ([]*model.RateLimit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRateLimitsForCache", mtime, firstUpdate)
	ret0, _ := ret[0].([]*model.RateLimit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRateLimitsForCache indicates an expected call of GetRateLimitsForCache.
func (mr *MockStoreMockRecorder) GetRateLimitsForCache(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimitsForCache", reflect.TypeOf((*MockStore)(nil).GetRateLimitsForCache), mtime, firstUpdate)
}

// GetRoutingConfigV2WithID mocks base method.
func (m *MockStore) GetRoutingConfigV2WithID(id string) (*model.RouterConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingConfigV2WithID", id)
	ret0, _ := ret[0].(*model.RouterConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRoutingConfigV2WithID indicates an expected call of GetRoutingConfigV2WithID.
func (mr *MockStoreMockRecorder) GetRoutingConfigV2WithID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigV2WithID", reflect.TypeOf((*MockStore)(nil).GetRoutingConfigV2WithID), id)
}

// GetRoutingConfigV2WithIDTx mocks base method.
func (m *MockStore) GetRoutingConfigV2WithIDTx(tx store.Tx, id string) (*model.RouterConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingConfigV2WithIDTx", tx, id)
	ret0, _ := ret[0].(*model.RouterConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRoutingConfigV2WithIDTx indicates an expected call of GetRoutingConfigV2WithIDTx.
func (mr *MockStoreMockRecorder) GetRoutingConfigV2WithIDTx(tx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigV2WithIDTx", reflect.TypeOf((*MockStore)(nil).GetRoutingConfigV2WithIDTx), tx, id)
}

// GetRoutingConfigWithID mocks base method.
func (m *MockStore) GetRoutingConfigWithID(id string) (*model.RoutingConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingConfigWithID", id)
	ret0, _ := ret[0].(*model.RoutingConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRoutingConfigWithID indicates an expected call of GetRoutingConfigWithID.
func (mr *MockStoreMockRecorder) GetRoutingConfigWithID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigWithID", reflect.TypeOf((*MockStore)(nil).GetRoutingConfigWithID), id)
}

// GetRoutingConfigWithService mocks base method.
func (m *MockStore) GetRoutingConfigWithService(name, namespace string) (*model.RoutingConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingConfigWithService", name, namespace)
	ret0, _ := ret[0].(*model.RoutingConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRoutingConfigWithService indicates an expected call of GetRoutingConfigWithService.
func (mr *MockStoreMockRecorder) GetRoutingConfigWithService(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigWithService", reflect.TypeOf((*MockStore)(nil).GetRoutingConfigWithService), name, namespace)
}

// GetRoutingConfigs mocks base method.
func (m *MockStore) GetRoutingConfigs(filter map[string]string, offset, limit uint32) (uint32, []*model.ExtendRoutingConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingConfigs", filter, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.ExtendRoutingConfig)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRoutingConfigs indicates an expected call of GetRoutingConfigs.
func (mr *MockStoreMockRecorder) GetRoutingConfigs(filter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigs", reflect.TypeOf((*MockStore)(nil).GetRoutingConfigs), filter, offset, limit)
}

// GetRoutingConfigsForCache mocks base method.
func (m *MockStore) GetRoutingConfigsForCache(mtime time.Time, firstUpdate bool) ([]*model.RoutingConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingConfigsForCache", mtime, firstUpdate)
	ret0, _ := ret[0].([]*model.RoutingConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRoutingConfigsForCache indicates an expected call of GetRoutingConfigsForCache.
func (mr *MockStoreMockRecorder) GetRoutingConfigsForCache(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigsForCache", reflect.TypeOf((*MockStore)(nil).GetRoutingConfigsForCache), mtime, firstUpdate)
}

// GetRoutingConfigsV2ForCache mocks base method.
func (m *MockStore) GetRoutingConfigsV2ForCache(mtime time.Time, firstUpdate bool) ([]*model.RouterConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingConfigsV2ForCache", mtime, firstUpdate)
	ret0, _ := ret[0].([]*model.RouterConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRoutingConfigsV2ForCache indicates an expected call of GetRoutingConfigsV2ForCache.
func (mr *MockStoreMockRecorder) GetRoutingConfigsV2ForCache(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigsV2ForCache", reflect.TypeOf((*MockStore)(nil).GetRoutingConfigsV2ForCache), mtime, firstUpdate)
}

// GetService mocks base method.
func (m *MockStore) GetService(name, namespace string) (*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetService", name, namespace)
	ret0, _ := ret[0].(*model.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetService indicates an expected call of GetService.
func (mr *MockStoreMockRecorder) GetService(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetService", reflect.TypeOf((*MockStore)(nil).GetService), name, namespace)
}

// GetServiceAliases mocks base method.
func (m *MockStore) GetServiceAliases(filter map[string]string, offset, limit uint32) (uint32, []*model.ServiceAlias, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceAliases", filter, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.ServiceAlias)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetServiceAliases indicates an expected call of GetServiceAliases.
func (mr *MockStoreMockRecorder) GetServiceAliases(filter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceAliases", reflect.TypeOf((*MockStore)(nil).GetServiceAliases), filter, offset, limit)
}

// GetServiceByID mocks base method.
func (m *MockStore) GetServiceByID(id string) (*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceByID", id)
	ret0, _ := ret[0].(*model.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceByID indicates an expected call of GetServiceByID.
func (mr *MockStoreMockRecorder) GetServiceByID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceByID", reflect.TypeOf((*MockStore)(nil).GetServiceByID), id)
}

// GetServices mocks base method.
func (m *MockStore) GetServices(serviceFilters, serviceMetas map[string]string, instanceFilters *store.InstanceArgs, offset, limit uint32) (uint32, []*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServices", serviceFilters, serviceMetas, instanceFilters, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.Service)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetServices indicates an expected call of GetServices.
func (mr *MockStoreMockRecorder) GetServices(serviceFilters, serviceMetas, instanceFilters, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServices", reflect.TypeOf((*MockStore)(nil).GetServices), serviceFilters, serviceMetas, instanceFilters, offset, limit)
}

// GetServicesBatch mocks base method.
func (m *MockStore) GetServicesBatch(services []*model.Service) ([]*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServicesBatch", services)
	ret0, _ := ret[0].([]*model.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServicesBatch indicates an expected call of GetServicesBatch.
func (mr *MockStoreMockRecorder) GetServicesBatch(services interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicesBatch", reflect.TypeOf((*MockStore)(nil).GetServicesBatch), services)
}

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

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

// GetSourceServiceToken mocks base method.
func (m *MockStore) GetSourceServiceToken(name, namespace string) (*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSourceServiceToken", name, namespace)
	ret0, _ := ret[0].(*model.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSourceServiceToken indicates an expected call of GetSourceServiceToken.
func (mr *MockStoreMockRecorder) GetSourceServiceToken(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSourceServiceToken", reflect.TypeOf((*MockStore)(nil).GetSourceServiceToken), name, namespace)
}

// GetStrategies mocks base method.
func (m *MockStore) GetStrategies(filters map[string]string, offset, limit uint32) (uint32, []*model.StrategyDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStrategies", filters, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.StrategyDetail)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStrategies indicates an expected call of GetStrategies.
func (mr *MockStoreMockRecorder) GetStrategies(filters, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStrategies", reflect.TypeOf((*MockStore)(nil).GetStrategies), filters, offset, limit)
}

// GetStrategyDetail mocks base method.
func (m *MockStore) GetStrategyDetail(id string) (*model.StrategyDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStrategyDetail", id)
	ret0, _ := ret[0].(*model.StrategyDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStrategyDetail indicates an expected call of GetStrategyDetail.
func (mr *MockStoreMockRecorder) GetStrategyDetail(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStrategyDetail", reflect.TypeOf((*MockStore)(nil).GetStrategyDetail), id)
}

// GetStrategyDetailsForCache mocks base method.
func (m *MockStore) GetStrategyDetailsForCache(mtime time.Time, firstUpdate bool) ([]*model.StrategyDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStrategyDetailsForCache", mtime, firstUpdate)
	ret0, _ := ret[0].([]*model.StrategyDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStrategyDetailsForCache indicates an expected call of GetStrategyDetailsForCache.
func (mr *MockStoreMockRecorder) GetStrategyDetailsForCache(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStrategyDetailsForCache", reflect.TypeOf((*MockStore)(nil).GetStrategyDetailsForCache), mtime, firstUpdate)
}

// GetStrategyResources mocks base method.
func (m *MockStore) GetStrategyResources(principalId string, principalRole model.PrincipalType) ([]model.StrategyResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStrategyResources", principalId, principalRole)
	ret0, _ := ret[0].([]model.StrategyResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStrategyResources indicates an expected call of GetStrategyResources.
func (mr *MockStoreMockRecorder) GetStrategyResources(principalId, principalRole interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStrategyResources", reflect.TypeOf((*MockStore)(nil).GetStrategyResources), principalId, principalRole)
}

// GetSubCount mocks base method.
func (m *MockStore) GetSubCount(user *model.User) (uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubCount", user)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubCount indicates an expected call of GetSubCount.
func (mr *MockStoreMockRecorder) GetSubCount(user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubCount", reflect.TypeOf((*MockStore)(nil).GetSubCount), user)
}

// GetSystemServices mocks base method.
func (m *MockStore) GetSystemServices() ([]*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSystemServices")
	ret0, _ := ret[0].([]*model.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUnHealthyInstances mocks base method.
func (m *MockStore) GetUnHealthyInstances(timeout time.Duration, limit uint32) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUnHealthyInstances", timeout, limit)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUnHealthyInstances indicates an expected call of GetUnHealthyInstances.
func (mr *MockStoreMockRecorder) GetUnHealthyInstances(timeout, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUnHealthyInstances", reflect.TypeOf((*MockStore)(nil).GetUnHealthyInstances), timeout, limit)
}

// GetUnixSecond mocks base method.
func (m *MockStore) GetUnixSecond(maxWait time.Duration) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUnixSecond", maxWait)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUnixSecond indicates an expected call of GetUnixSecond.
func (mr *MockStoreMockRecorder) GetUnixSecond(maxWait interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUnixSecond", reflect.TypeOf((*MockStore)(nil).GetUnixSecond), maxWait)
}

// GetUser mocks base method.
func (m *MockStore) GetUser(id string) (*model.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUser", id)
	ret0, _ := ret[0].(*model.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUser indicates an expected call of GetUser.
func (mr *MockStoreMockRecorder) GetUser(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockStore)(nil).GetUser), id)
}

// GetUserByIds mocks base method.
func (m *MockStore) GetUserByIds(ids []string) ([]*model.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByIds", ids)
	ret0, _ := ret[0].([]*model.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserByIds indicates an expected call of GetUserByIds.
func (mr *MockStoreMockRecorder) GetUserByIds(ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByIds", reflect.TypeOf((*MockStore)(nil).GetUserByIds), ids)
}

// GetUserByName mocks base method.
func (m *MockStore) GetUserByName(name, ownerId string) (*model.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByName", name, ownerId)
	ret0, _ := ret[0].(*model.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserByName indicates an expected call of GetUserByName.
func (mr *MockStoreMockRecorder) GetUserByName(name, ownerId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByName", reflect.TypeOf((*MockStore)(nil).GetUserByName), name, ownerId)
}

// GetUsers mocks base method.
func (m *MockStore) GetUsers(filters map[string]string, offset, limit uint32) (uint32, []*model.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUsers", filters, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.User)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetUsers indicates an expected call of GetUsers.
func (mr *MockStoreMockRecorder) GetUsers(filters, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsers", reflect.TypeOf((*MockStore)(nil).GetUsers), filters, offset, limit)
}

// GetUsersForCache mocks base method.
func (m *MockStore) GetUsersForCache(mtime time.Time, firstUpdate bool) ([]*model.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUsersForCache", mtime, firstUpdate)
	ret0, _ := ret[0].([]*model.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUsersForCache indicates an expected call of GetUsersForCache.
func (mr *MockStoreMockRecorder) GetUsersForCache(mtime, firstUpdate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsersForCache", reflect.TypeOf((*MockStore)(nil).GetUsersForCache), mtime, firstUpdate)
}

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

// HasCircuitBreakerRule indicates an expected call of HasCircuitBreakerRule.
func (mr *MockStoreMockRecorder) HasCircuitBreakerRule(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasCircuitBreakerRule", reflect.TypeOf((*MockStore)(nil).HasCircuitBreakerRule), id)
}

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

// HasCircuitBreakerRuleByName indicates an expected call of HasCircuitBreakerRuleByName.
func (mr *MockStoreMockRecorder) HasCircuitBreakerRuleByName(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasCircuitBreakerRuleByName", reflect.TypeOf((*MockStore)(nil).HasCircuitBreakerRuleByName), name, namespace)
}

// HasCircuitBreakerRuleByNameExcludeId mocks base method.
func (m *MockStore) HasCircuitBreakerRuleByNameExcludeId(name, namespace, id string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasCircuitBreakerRuleByNameExcludeId", name, namespace, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasCircuitBreakerRuleByNameExcludeId indicates an expected call of HasCircuitBreakerRuleByNameExcludeId.
func (mr *MockStoreMockRecorder) HasCircuitBreakerRuleByNameExcludeId(name, namespace, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasCircuitBreakerRuleByNameExcludeId", reflect.TypeOf((*MockStore)(nil).HasCircuitBreakerRuleByNameExcludeId), name, namespace, id)
}

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

// HasFaultDetectRule indicates an expected call of HasFaultDetectRule.
func (mr *MockStoreMockRecorder) HasFaultDetectRule(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasFaultDetectRule", reflect.TypeOf((*MockStore)(nil).HasFaultDetectRule), id)
}

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

// HasFaultDetectRuleByName indicates an expected call of HasFaultDetectRuleByName.
func (mr *MockStoreMockRecorder) HasFaultDetectRuleByName(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasFaultDetectRuleByName", reflect.TypeOf((*MockStore)(nil).HasFaultDetectRuleByName), name, namespace)
}

// HasFaultDetectRuleByNameExcludeId mocks base method.
func (m *MockStore) HasFaultDetectRuleByNameExcludeId(name, namespace, id string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasFaultDetectRuleByNameExcludeId", name, namespace, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasFaultDetectRuleByNameExcludeId indicates an expected call of HasFaultDetectRuleByNameExcludeId.
func (mr *MockStoreMockRecorder) HasFaultDetectRuleByNameExcludeId(name, namespace, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasFaultDetectRuleByNameExcludeId", reflect.TypeOf((*MockStore)(nil).HasFaultDetectRuleByNameExcludeId), name, namespace, id)
}

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

// Initialize indicates an expected call of Initialize.
func (mr *MockStoreMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockStore)(nil).Initialize), c)
}

// IsLeader mocks base method.
func (m *MockStore) IsLeader(key string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsLeader", key)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsLeader indicates an expected call of IsLeader.
func (mr *MockStoreMockRecorder) IsLeader(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsLeader", reflect.TypeOf((*MockStore)(nil).IsLeader), key)
}

// ListLeaderElections mocks base method.
func (m *MockStore) ListLeaderElections() ([]*model.LeaderElection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLeaderElections")
	ret0, _ := ret[0].([]*model.LeaderElection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LockConfigFile mocks base method.
func (m *MockStore) LockConfigFile(tx store.Tx, file *model.ConfigFileKey) (*model.ConfigFile, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockConfigFile", tx, file)
	ret0, _ := ret[0].(*model.ConfigFile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LockConfigFile indicates an expected call of LockConfigFile.
func (mr *MockStoreMockRecorder) LockConfigFile(tx, file interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockConfigFile", reflect.TypeOf((*MockStore)(nil).LockConfigFile), tx, file)
}

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

// LooseAddStrategyResources indicates an expected call of LooseAddStrategyResources.
func (mr *MockStoreMockRecorder) LooseAddStrategyResources(resources interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LooseAddStrategyResources", reflect.TypeOf((*MockStore)(nil).LooseAddStrategyResources), resources)
}

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

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

// QueryAllConfigFileTemplates mocks base method.
func (m *MockStore) QueryAllConfigFileTemplates() ([]*model.ConfigFileTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryAllConfigFileTemplates")
	ret0, _ := ret[0].([]*model.ConfigFileTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryConfigFileReleaseHistories mocks base method.
func (m *MockStore) QueryConfigFileReleaseHistories(filter map[string]string, offset, limit uint32) (uint32, []*model.ConfigFileReleaseHistory, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryConfigFileReleaseHistories", filter, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.ConfigFileReleaseHistory)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryConfigFileReleaseHistories indicates an expected call of QueryConfigFileReleaseHistories.
func (mr *MockStoreMockRecorder) QueryConfigFileReleaseHistories(filter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConfigFileReleaseHistories", reflect.TypeOf((*MockStore)(nil).QueryConfigFileReleaseHistories), filter, offset, limit)
}

// QueryConfigFiles mocks base method.
func (m *MockStore) QueryConfigFiles(filter map[string]string, offset, limit uint32) (uint32, []*model.ConfigFile, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryConfigFiles", filter, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.ConfigFile)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryConfigFiles indicates an expected call of QueryConfigFiles.
func (mr *MockStoreMockRecorder) QueryConfigFiles(filter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryConfigFiles", reflect.TypeOf((*MockStore)(nil).QueryConfigFiles), filter, offset, limit)
}

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

// ReleaseLeaderElection indicates an expected call of ReleaseLeaderElection.
func (mr *MockStoreMockRecorder) ReleaseLeaderElection(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseLeaderElection", reflect.TypeOf((*MockStore)(nil).ReleaseLeaderElection), key)
}

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

// RemoveStrategyResources indicates an expected call of RemoveStrategyResources.
func (mr *MockStoreMockRecorder) RemoveStrategyResources(resources interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveStrategyResources", reflect.TypeOf((*MockStore)(nil).RemoveStrategyResources), resources)
}

// SetInstanceHealthStatus mocks base method.
func (m *MockStore) SetInstanceHealthStatus(instanceID string, flag int, revision string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInstanceHealthStatus", instanceID, flag, revision)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetInstanceHealthStatus indicates an expected call of SetInstanceHealthStatus.
func (mr *MockStoreMockRecorder) SetInstanceHealthStatus(instanceID, flag, revision interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceHealthStatus", reflect.TypeOf((*MockStore)(nil).SetInstanceHealthStatus), instanceID, flag, revision)
}

// SetL5Extend mocks base method.
func (m *MockStore) SetL5Extend(serviceID string, meta map[string]interface{}) (map[string]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetL5Extend", serviceID, meta)
	ret0, _ := ret[0].(map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetL5Extend indicates an expected call of SetL5Extend.
func (mr *MockStoreMockRecorder) SetL5Extend(serviceID, meta interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetL5Extend", reflect.TypeOf((*MockStore)(nil).SetL5Extend), serviceID, meta)
}

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

// StartLeaderElection indicates an expected call of StartLeaderElection.
func (mr *MockStoreMockRecorder) StartLeaderElection(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartLeaderElection", reflect.TypeOf((*MockStore)(nil).StartLeaderElection), key)
}

// StartReadTx mocks base method.
func (m *MockStore) StartReadTx() (store.Tx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartReadTx")
	ret0, _ := ret[0].(store.Tx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartTx mocks base method.
func (m *MockStore) StartTx() (store.Tx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartTx")
	ret0, _ := ret[0].(store.Tx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// UpdateCircuitBreakerRule indicates an expected call of UpdateCircuitBreakerRule.
func (mr *MockStoreMockRecorder) UpdateCircuitBreakerRule(cbRule interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCircuitBreakerRule", reflect.TypeOf((*MockStore)(nil).UpdateCircuitBreakerRule), cbRule)
}

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

// UpdateConfigFileGroup indicates an expected call of UpdateConfigFileGroup.
func (mr *MockStoreMockRecorder) UpdateConfigFileGroup(fileGroup interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConfigFileGroup", reflect.TypeOf((*MockStore)(nil).UpdateConfigFileGroup), fileGroup)
}

// UpdateConfigFileTx mocks base method.
func (m *MockStore) UpdateConfigFileTx(tx store.Tx, file *model.ConfigFile) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateConfigFileTx", tx, file)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateConfigFileTx indicates an expected call of UpdateConfigFileTx.
func (mr *MockStoreMockRecorder) UpdateConfigFileTx(tx, file interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConfigFileTx", reflect.TypeOf((*MockStore)(nil).UpdateConfigFileTx), tx, file)
}

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

// UpdateFaultDetectRule indicates an expected call of UpdateFaultDetectRule.
func (mr *MockStoreMockRecorder) UpdateFaultDetectRule(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFaultDetectRule", reflect.TypeOf((*MockStore)(nil).UpdateFaultDetectRule), conf)
}

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

// UpdateGroup indicates an expected call of UpdateGroup.
func (mr *MockStoreMockRecorder) UpdateGroup(group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroup", reflect.TypeOf((*MockStore)(nil).UpdateGroup), group)
}

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

// UpdateInstance indicates an expected call of UpdateInstance.
func (mr *MockStoreMockRecorder) UpdateInstance(instance interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInstance", reflect.TypeOf((*MockStore)(nil).UpdateInstance), instance)
}

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

// UpdateNamespace indicates an expected call of UpdateNamespace.
func (mr *MockStoreMockRecorder) UpdateNamespace(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockStore)(nil).UpdateNamespace), namespace)
}

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

// UpdateNamespaceToken indicates an expected call of UpdateNamespaceToken.
func (mr *MockStoreMockRecorder) UpdateNamespaceToken(name, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespaceToken", reflect.TypeOf((*MockStore)(nil).UpdateNamespaceToken), name, token)
}

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

// UpdateRateLimit indicates an expected call of UpdateRateLimit.
func (mr *MockStoreMockRecorder) UpdateRateLimit(limiting interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRateLimit", reflect.TypeOf((*MockStore)(nil).UpdateRateLimit), limiting)
}

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

// UpdateRoutingConfig indicates an expected call of UpdateRoutingConfig.
func (mr *MockStoreMockRecorder) UpdateRoutingConfig(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoutingConfig", reflect.TypeOf((*MockStore)(nil).UpdateRoutingConfig), conf)
}

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

// UpdateRoutingConfigV2 indicates an expected call of UpdateRoutingConfigV2.
func (mr *MockStoreMockRecorder) UpdateRoutingConfigV2(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoutingConfigV2", reflect.TypeOf((*MockStore)(nil).UpdateRoutingConfigV2), conf)
}

// UpdateRoutingConfigV2Tx mocks base method.
func (m *MockStore) UpdateRoutingConfigV2Tx(tx store.Tx, conf *model.RouterConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRoutingConfigV2Tx", tx, conf)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateRoutingConfigV2Tx indicates an expected call of UpdateRoutingConfigV2Tx.
func (mr *MockStoreMockRecorder) UpdateRoutingConfigV2Tx(tx, conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoutingConfigV2Tx", reflect.TypeOf((*MockStore)(nil).UpdateRoutingConfigV2Tx), tx, conf)
}

// UpdateService mocks base method.
func (m *MockStore) UpdateService(service *model.Service, needUpdateOwner bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateService", service, needUpdateOwner)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateService indicates an expected call of UpdateService.
func (mr *MockStoreMockRecorder) UpdateService(service, needUpdateOwner interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateService", reflect.TypeOf((*MockStore)(nil).UpdateService), service, needUpdateOwner)
}

// UpdateServiceAlias mocks base method.
func (m *MockStore) UpdateServiceAlias(alias *model.Service, needUpdateOwner bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServiceAlias", alias, needUpdateOwner)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateServiceAlias indicates an expected call of UpdateServiceAlias.
func (mr *MockStoreMockRecorder) UpdateServiceAlias(alias, needUpdateOwner interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceAlias", reflect.TypeOf((*MockStore)(nil).UpdateServiceAlias), alias, needUpdateOwner)
}

// UpdateServiceToken mocks base method.
func (m *MockStore) UpdateServiceToken(serviceID, token, revision string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServiceToken", serviceID, token, revision)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateServiceToken indicates an expected call of UpdateServiceToken.
func (mr *MockStoreMockRecorder) UpdateServiceToken(serviceID, token, revision interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceToken", reflect.TypeOf((*MockStore)(nil).UpdateServiceToken), serviceID, token, revision)
}

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

// UpdateStrategy indicates an expected call of UpdateStrategy.
func (mr *MockStoreMockRecorder) UpdateStrategy(strategy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStrategy", reflect.TypeOf((*MockStore)(nil).UpdateStrategy), strategy)
}

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

// UpdateUser indicates an expected call of UpdateUser.
func (mr *MockStoreMockRecorder) UpdateUser(user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockStore)(nil).UpdateUser), user)
}

// MockNamespaceStore is a mock of NamespaceStore interface.
type MockNamespaceStore struct {
	ctrl     *gomock.Controller
	recorder *MockNamespaceStoreMockRecorder
}

// MockNamespaceStoreMockRecorder is the mock recorder for MockNamespaceStore.
type MockNamespaceStoreMockRecorder struct {
	mock *MockNamespaceStore
}

// NewMockNamespaceStore creates a new mock instance.
func NewMockNamespaceStore(ctrl *gomock.Controller) *MockNamespaceStore {
	mock := &MockNamespaceStore{ctrl: ctrl}
	mock.recorder = &MockNamespaceStoreMockRecorder{mock}
	return mock
}

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

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

// AddNamespace indicates an expected call of AddNamespace.
func (mr *MockNamespaceStoreMockRecorder) AddNamespace(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNamespace", reflect.TypeOf((*MockNamespaceStore)(nil).AddNamespace), namespace)
}

// GetMoreNamespaces mocks base method.
func (m *MockNamespaceStore) GetMoreNamespaces(mtime time.Time) ([]*model.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMoreNamespaces", mtime)
	ret0, _ := ret[0].([]*model.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMoreNamespaces indicates an expected call of GetMoreNamespaces.
func (mr *MockNamespaceStoreMockRecorder) GetMoreNamespaces(mtime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMoreNamespaces", reflect.TypeOf((*MockNamespaceStore)(nil).GetMoreNamespaces), mtime)
}

// GetNamespace mocks base method.
func (m *MockNamespaceStore) GetNamespace(name string) (*model.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", name)
	ret0, _ := ret[0].(*model.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespace indicates an expected call of GetNamespace.
func (mr *MockNamespaceStoreMockRecorder) GetNamespace(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockNamespaceStore)(nil).GetNamespace), name)
}

// GetNamespaces mocks base method.
func (m *MockNamespaceStore) GetNamespaces(filter map[string][]string, offset, limit int) ([]*model.Namespace, uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaces", filter, offset, limit)
	ret0, _ := ret[0].([]*model.Namespace)
	ret1, _ := ret[1].(uint32)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetNamespaces indicates an expected call of GetNamespaces.
func (mr *MockNamespaceStoreMockRecorder) GetNamespaces(filter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaces", reflect.TypeOf((*MockNamespaceStore)(nil).GetNamespaces), filter, offset, limit)
}

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

// UpdateNamespace indicates an expected call of UpdateNamespace.
func (mr *MockNamespaceStoreMockRecorder) UpdateNamespace(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockNamespaceStore)(nil).UpdateNamespace), namespace)
}

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

// UpdateNamespaceToken indicates an expected call of UpdateNamespaceToken.
func (mr *MockNamespaceStoreMockRecorder) UpdateNamespaceToken(name, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespaceToken", reflect.TypeOf((*MockNamespaceStore)(nil).UpdateNamespaceToken), name, token)
}

// MockTransaction is a mock of Transaction interface.
type MockTransaction struct {
	ctrl     *gomock.Controller
	recorder *MockTransactionMockRecorder
}

// MockTransactionMockRecorder is the mock recorder for MockTransaction.
type MockTransactionMockRecorder struct {
	mock *MockTransaction
}

// NewMockTransaction creates a new mock instance.
func NewMockTransaction(ctrl *gomock.Controller) *MockTransaction {
	mock := &MockTransaction{ctrl: ctrl}
	mock.recorder = &MockTransactionMockRecorder{mock}
	return mock
}

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

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

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

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

// DeleteNamespace indicates an expected call of DeleteNamespace.
func (mr *MockTransactionMockRecorder) DeleteNamespace(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespace", reflect.TypeOf((*MockTransaction)(nil).DeleteNamespace), name)
}

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

// LockBootstrap indicates an expected call of LockBootstrap.
func (mr *MockTransactionMockRecorder) LockBootstrap(key, server interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockBootstrap", reflect.TypeOf((*MockTransaction)(nil).LockBootstrap), key, server)
}

// LockNamespace mocks base method.
func (m *MockTransaction) LockNamespace(name string) (*model.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockNamespace", name)
	ret0, _ := ret[0].(*model.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LockNamespace indicates an expected call of LockNamespace.
func (mr *MockTransactionMockRecorder) LockNamespace(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockNamespace", reflect.TypeOf((*MockTransaction)(nil).LockNamespace), name)
}

// LockService mocks base method.
func (m *MockTransaction) LockService(name, namespace string) (*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockService", name, namespace)
	ret0, _ := ret[0].(*model.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LockService indicates an expected call of LockService.
func (mr *MockTransactionMockRecorder) LockService(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockService", reflect.TypeOf((*MockTransaction)(nil).LockService), name, namespace)
}

// RLockService mocks base method.
func (m *MockTransaction) RLockService(name, namespace string) (*model.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RLockService", name, namespace)
	ret0, _ := ret[0].(*model.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RLockService indicates an expected call of RLockService.
func (mr *MockTransactionMockRecorder) RLockService(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RLockService", reflect.TypeOf((*MockTransaction)(nil).RLockService), name, namespace)
}

// MockTx is a mock of Tx interface.
type MockTx struct {
	ctrl     *gomock.Controller
	recorder *MockTxMockRecorder
}

// MockTxMockRecorder is the mock recorder for MockTx.
type MockTxMockRecorder struct {
	mock *MockTx
}

// NewMockTx creates a new mock instance.
func NewMockTx(ctrl *gomock.Controller) *MockTx {
	mock := &MockTx{ctrl: ctrl}
	mock.recorder = &MockTxMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockToolStore is a mock of ToolStore interface.
type MockToolStore struct {
	ctrl     *gomock.Controller
	recorder *MockToolStoreMockRecorder
}

// MockToolStoreMockRecorder is the mock recorder for MockToolStore.
type MockToolStoreMockRecorder struct {
	mock *MockToolStore
}

// NewMockToolStore creates a new mock instance.
func NewMockToolStore(ctrl *gomock.Controller) *MockToolStore {
	mock := &MockToolStore{ctrl: ctrl}
	mock.recorder = &MockToolStoreMockRecorder{mock}
	return mock
}

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

// GetUnixSecond mocks base method.
func (m *MockToolStore) GetUnixSecond(maxWait time.Duration) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUnixSecond", maxWait)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUnixSecond indicates an expected call of GetUnixSecond.
func (mr *MockToolStoreMockRecorder) GetUnixSecond(maxWait interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUnixSecond", reflect.TypeOf((*MockToolStore)(nil).GetUnixSecond), maxWait)
}