netbird/management/server/store/store_mock.go

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

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

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

	gomock "github.com/golang/mock/gomock"
	dns "github.com/netbirdio/netbird/dns"
	accesslogs "github.com/netbirdio/netbird/management/internals/modules/reverseproxy/accesslogs"
	domain "github.com/netbirdio/netbird/management/internals/modules/reverseproxy/domain"
	proxy "github.com/netbirdio/netbird/management/internals/modules/reverseproxy/proxy"
	service "github.com/netbirdio/netbird/management/internals/modules/reverseproxy/service"
	zones "github.com/netbirdio/netbird/management/internals/modules/zones"
	records "github.com/netbirdio/netbird/management/internals/modules/zones/records"
	types "github.com/netbirdio/netbird/management/server/networks/resources/types"
	types0 "github.com/netbirdio/netbird/management/server/networks/routers/types"
	types1 "github.com/netbirdio/netbird/management/server/networks/types"
	peer "github.com/netbirdio/netbird/management/server/peer"
	posture "github.com/netbirdio/netbird/management/server/posture"
	types2 "github.com/netbirdio/netbird/management/server/types"
	route "github.com/netbirdio/netbird/route"
	crypt "github.com/netbirdio/netbird/util/crypt"
)

// 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
}

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

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

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

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

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

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

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

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

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

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

// AddResourceToGroup mocks base method.
func (m *MockStore) AddResourceToGroup(ctx context.Context, accountId, groupID string, resource *types2.Resource) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddResourceToGroup", ctx, accountId, groupID, resource)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

// CountEphemeralServicesByPeer mocks base method.
func (m *MockStore) CountEphemeralServicesByPeer(ctx context.Context, lockStrength LockingStrength, accountID, peerID string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountEphemeralServicesByPeer", ctx, lockStrength, accountID, peerID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CreateCustomDomain mocks base method.
func (m *MockStore) CreateCustomDomain(ctx context.Context, accountID, domainName, targetCluster string, validated bool) (*domain.Domain, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCustomDomain", ctx, accountID, domainName, targetCluster, validated)
	ret0, _ := ret[0].(*domain.Domain)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCustomDomain indicates an expected call of CreateCustomDomain.
func (mr *MockStoreMockRecorder) CreateCustomDomain(ctx, accountID, domainName, targetCluster, validated interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomDomain", reflect.TypeOf((*MockStore)(nil).CreateCustomDomain), ctx, accountID, domainName, targetCluster, validated)
}

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

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

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

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

// CreateGroups mocks base method.
func (m *MockStore) CreateGroups(ctx context.Context, accountID string, groups []*types2.Group) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGroups", ctx, accountID, groups)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DeleteOldAccessLogs mocks base method.
func (m *MockStore) DeleteOldAccessLogs(ctx context.Context, olderThan time.Time) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldAccessLogs", ctx, olderThan)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DeleteTarget mocks base method.
func (m *MockStore) DeleteTarget(ctx context.Context, accountID, serviceID string, targetID uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTarget", ctx, accountID, serviceID, targetID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

// EphemeralServiceExists mocks base method.
func (m *MockStore) EphemeralServiceExists(ctx context.Context, lockStrength LockingStrength, accountID, peerID, domain string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EphemeralServiceExists", ctx, lockStrength, accountID, peerID, domain)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EphemeralServiceExists indicates an expected call of EphemeralServiceExists.
func (mr *MockStoreMockRecorder) EphemeralServiceExists(ctx, lockStrength, accountID, peerID, domain interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EphemeralServiceExists", reflect.TypeOf((*MockStore)(nil).EphemeralServiceExists), ctx, lockStrength, accountID, peerID, domain)
}

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

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

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

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

// GetAccountAccessLogs mocks base method.
func (m *MockStore) GetAccountAccessLogs(ctx context.Context, lockStrength LockingStrength, accountID string, filter accesslogs.AccessLogFilter) ([]*accesslogs.AccessLogEntry, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountAccessLogs", ctx, lockStrength, accountID, filter)
	ret0, _ := ret[0].([]*accesslogs.AccessLogEntry)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetAccountDNSSettings mocks base method.
func (m *MockStore) GetAccountDNSSettings(ctx context.Context, lockStrength LockingStrength, accountID string) (*types2.DNSSettings, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountDNSSettings", ctx, lockStrength, accountID)
	ret0, _ := ret[0].(*types2.DNSSettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountDomainAndCategory mocks base method.
func (m *MockStore) GetAccountDomainAndCategory(ctx context.Context, lockStrength LockingStrength, accountID string) (string, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountDomainAndCategory", ctx, lockStrength, accountID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetAccountGroupPeers mocks base method.
func (m *MockStore) GetAccountGroupPeers(ctx context.Context, lockStrength LockingStrength, accountID string) (map[string]map[string]struct{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountGroupPeers", ctx, lockStrength, accountID)
	ret0, _ := ret[0].(map[string]map[string]struct{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountGroups mocks base method.
func (m *MockStore) GetAccountGroups(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*types2.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountGroups", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*types2.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

// GetAccountMeta mocks base method.
func (m *MockStore) GetAccountMeta(ctx context.Context, lockStrength LockingStrength, accountID string) (*types2.AccountMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountMeta", ctx, lockStrength, accountID)
	ret0, _ := ret[0].(*types2.AccountMeta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountNameServerGroups mocks base method.
func (m *MockStore) GetAccountNameServerGroups(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*dns.NameServerGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountNameServerGroups", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*dns.NameServerGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountNetwork mocks base method.
func (m *MockStore) GetAccountNetwork(ctx context.Context, lockStrength LockingStrength, accountId string) (*types2.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountNetwork", ctx, lockStrength, accountId)
	ret0, _ := ret[0].(*types2.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountNetworks mocks base method.
func (m *MockStore) GetAccountNetworks(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*types1.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountNetworks", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*types1.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetAccountOwner mocks base method.
func (m *MockStore) GetAccountOwner(ctx context.Context, lockStrength LockingStrength, accountID string) (*types2.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountOwner", ctx, lockStrength, accountID)
	ret0, _ := ret[0].(*types2.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountPeers mocks base method.
func (m *MockStore) GetAccountPeers(ctx context.Context, lockStrength LockingStrength, accountID, nameFilter, ipFilter string) ([]*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountPeers", ctx, lockStrength, accountID, nameFilter, ipFilter)
	ret0, _ := ret[0].([]*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountPeers indicates an expected call of GetAccountPeers.
func (mr *MockStoreMockRecorder) GetAccountPeers(ctx, lockStrength, accountID, nameFilter, ipFilter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountPeers", reflect.TypeOf((*MockStore)(nil).GetAccountPeers), ctx, lockStrength, accountID, nameFilter, ipFilter)
}

// GetAccountPeersWithExpiration mocks base method.
func (m *MockStore) GetAccountPeersWithExpiration(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountPeersWithExpiration", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountPeersWithInactivity mocks base method.
func (m *MockStore) GetAccountPeersWithInactivity(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountPeersWithInactivity", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountPolicies mocks base method.
func (m *MockStore) GetAccountPolicies(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*types2.Policy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountPolicies", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*types2.Policy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountPostureChecks mocks base method.
func (m *MockStore) GetAccountPostureChecks(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*posture.Checks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountPostureChecks", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*posture.Checks)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountRoutes mocks base method.
func (m *MockStore) GetAccountRoutes(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*route.Route, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountRoutes", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*route.Route)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountServices mocks base method.
func (m *MockStore) GetAccountServices(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*service.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountServices", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*service.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountSettings mocks base method.
func (m *MockStore) GetAccountSettings(ctx context.Context, lockStrength LockingStrength, accountID string) (*types2.Settings, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountSettings", ctx, lockStrength, accountID)
	ret0, _ := ret[0].(*types2.Settings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountSetupKeys mocks base method.
func (m *MockStore) GetAccountSetupKeys(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*types2.SetupKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountSetupKeys", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*types2.SetupKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountUserInvites mocks base method.
func (m *MockStore) GetAccountUserInvites(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*types2.UserInviteRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountUserInvites", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*types2.UserInviteRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountUsers mocks base method.
func (m *MockStore) GetAccountUsers(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*types2.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountUsers", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*types2.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAccountZones mocks base method.
func (m *MockStore) GetAccountZones(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*zones.Zone, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountZones", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*zones.Zone)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// GetAllEphemeralPeers mocks base method.
func (m *MockStore) GetAllEphemeralPeers(ctx context.Context, lockStrength LockingStrength) ([]*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllEphemeralPeers", ctx, lockStrength)
	ret0, _ := ret[0].([]*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllProxyAccessTokens mocks base method.
func (m *MockStore) GetAllProxyAccessTokens(ctx context.Context, lockStrength LockingStrength) ([]*types2.ProxyAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllProxyAccessTokens", ctx, lockStrength)
	ret0, _ := ret[0].([]*types2.ProxyAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// GetDNSRecordByID mocks base method.
func (m *MockStore) GetDNSRecordByID(ctx context.Context, lockStrength LockingStrength, accountID, zoneID, recordID string) (*records.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDNSRecordByID", ctx, lockStrength, accountID, zoneID, recordID)
	ret0, _ := ret[0].(*records.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDNSRecordByID indicates an expected call of GetDNSRecordByID.
func (mr *MockStoreMockRecorder) GetDNSRecordByID(ctx, lockStrength, accountID, zoneID, recordID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDNSRecordByID", reflect.TypeOf((*MockStore)(nil).GetDNSRecordByID), ctx, lockStrength, accountID, zoneID, recordID)
}

// GetExpiredEphemeralServices mocks base method.
func (m *MockStore) GetExpiredEphemeralServices(ctx context.Context, ttl time.Duration, limit int) ([]*service.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExpiredEphemeralServices", ctx, ttl, limit)
	ret0, _ := ret[0].([]*service.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGroupByID mocks base method.
func (m *MockStore) GetGroupByID(ctx context.Context, lockStrength LockingStrength, accountID, groupID string) (*types2.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupByID", ctx, lockStrength, accountID, groupID)
	ret0, _ := ret[0].(*types2.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGroupByName mocks base method.
func (m *MockStore) GetGroupByName(ctx context.Context, lockStrength LockingStrength, groupName, accountID string) (*types2.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupByName", ctx, lockStrength, groupName, accountID)
	ret0, _ := ret[0].(*types2.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGroupsByIDs mocks base method.
func (m *MockStore) GetGroupsByIDs(ctx context.Context, lockStrength LockingStrength, accountID string, groupIDs []string) (map[string]*types2.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupsByIDs", ctx, lockStrength, accountID, groupIDs)
	ret0, _ := ret[0].(map[string]*types2.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetNameServerGroupByID mocks base method.
func (m *MockStore) GetNameServerGroupByID(ctx context.Context, lockStrength LockingStrength, nameServerGroupID, accountID string) (*dns.NameServerGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNameServerGroupByID", ctx, lockStrength, nameServerGroupID, accountID)
	ret0, _ := ret[0].(*dns.NameServerGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkByID mocks base method.
func (m *MockStore) GetNetworkByID(ctx context.Context, lockStrength LockingStrength, accountID, networkID string) (*types1.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkByID", ctx, lockStrength, accountID, networkID)
	ret0, _ := ret[0].(*types1.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkResourceByID mocks base method.
func (m *MockStore) GetNetworkResourceByID(ctx context.Context, lockStrength LockingStrength, accountID, resourceID string) (*types.NetworkResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkResourceByID", ctx, lockStrength, accountID, resourceID)
	ret0, _ := ret[0].(*types.NetworkResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkResourceByName mocks base method.
func (m *MockStore) GetNetworkResourceByName(ctx context.Context, lockStrength LockingStrength, accountID, resourceName string) (*types.NetworkResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkResourceByName", ctx, lockStrength, accountID, resourceName)
	ret0, _ := ret[0].(*types.NetworkResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkResourcesByAccountID mocks base method.
func (m *MockStore) GetNetworkResourcesByAccountID(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*types.NetworkResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkResourcesByAccountID", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*types.NetworkResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkResourcesByNetID mocks base method.
func (m *MockStore) GetNetworkResourcesByNetID(ctx context.Context, lockStrength LockingStrength, accountID, netID string) ([]*types.NetworkResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkResourcesByNetID", ctx, lockStrength, accountID, netID)
	ret0, _ := ret[0].([]*types.NetworkResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkRouterByID mocks base method.
func (m *MockStore) GetNetworkRouterByID(ctx context.Context, lockStrength LockingStrength, accountID, routerID string) (*types0.NetworkRouter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkRouterByID", ctx, lockStrength, accountID, routerID)
	ret0, _ := ret[0].(*types0.NetworkRouter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkRoutersByAccountID mocks base method.
func (m *MockStore) GetNetworkRoutersByAccountID(ctx context.Context, lockStrength LockingStrength, accountID string) ([]*types0.NetworkRouter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkRoutersByAccountID", ctx, lockStrength, accountID)
	ret0, _ := ret[0].([]*types0.NetworkRouter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkRoutersByNetID mocks base method.
func (m *MockStore) GetNetworkRoutersByNetID(ctx context.Context, lockStrength LockingStrength, accountID, netID string) ([]*types0.NetworkRouter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkRoutersByNetID", ctx, lockStrength, accountID, netID)
	ret0, _ := ret[0].([]*types0.NetworkRouter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPATByHashedToken mocks base method.
func (m *MockStore) GetPATByHashedToken(ctx context.Context, lockStrength LockingStrength, hashedToken string) (*types2.PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPATByHashedToken", ctx, lockStrength, hashedToken)
	ret0, _ := ret[0].(*types2.PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPATByID mocks base method.
func (m *MockStore) GetPATByID(ctx context.Context, lockStrength LockingStrength, userID, patID string) (*types2.PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPATByID", ctx, lockStrength, userID, patID)
	ret0, _ := ret[0].(*types2.PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPeerByID mocks base method.
func (m *MockStore) GetPeerByID(ctx context.Context, lockStrength LockingStrength, accountID, peerID string) (*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeerByID", ctx, lockStrength, accountID, peerID)
	ret0, _ := ret[0].(*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPeerByIP mocks base method.
func (m *MockStore) GetPeerByIP(ctx context.Context, lockStrength LockingStrength, accountID string, ip net.IP) (*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeerByIP", ctx, lockStrength, accountID, ip)
	ret0, _ := ret[0].(*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPeerByPeerPubKey mocks base method.
func (m *MockStore) GetPeerByPeerPubKey(ctx context.Context, lockStrength LockingStrength, peerKey string) (*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeerByPeerPubKey", ctx, lockStrength, peerKey)
	ret0, _ := ret[0].(*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetPeerGroups mocks base method.
func (m *MockStore) GetPeerGroups(ctx context.Context, lockStrength LockingStrength, accountId, peerId string) ([]*types2.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeerGroups", ctx, lockStrength, accountId, peerId)
	ret0, _ := ret[0].([]*types2.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetPeersByIDs mocks base method.
func (m *MockStore) GetPeersByIDs(ctx context.Context, lockStrength LockingStrength, accountID string, peerIDs []string) (map[string]*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeersByIDs", ctx, lockStrength, accountID, peerIDs)
	ret0, _ := ret[0].(map[string]*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPolicyByID mocks base method.
func (m *MockStore) GetPolicyByID(ctx context.Context, lockStrength LockingStrength, accountID, policyID string) (*types2.Policy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicyByID", ctx, lockStrength, accountID, policyID)
	ret0, _ := ret[0].(*types2.Policy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPolicyRulesByResourceID mocks base method.
func (m *MockStore) GetPolicyRulesByResourceID(ctx context.Context, lockStrength LockingStrength, accountID, peerID string) ([]*types2.PolicyRule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicyRulesByResourceID", ctx, lockStrength, accountID, peerID)
	ret0, _ := ret[0].([]*types2.PolicyRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPostureCheckByChecksDefinition mocks base method.
func (m *MockStore) GetPostureCheckByChecksDefinition(accountID string, checks *posture.ChecksDefinition) (*posture.Checks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPostureCheckByChecksDefinition", accountID, checks)
	ret0, _ := ret[0].(*posture.Checks)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPostureChecksByID mocks base method.
func (m *MockStore) GetPostureChecksByID(ctx context.Context, lockStrength LockingStrength, accountID, postureCheckID string) (*posture.Checks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPostureChecksByID", ctx, lockStrength, accountID, postureCheckID)
	ret0, _ := ret[0].(*posture.Checks)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPostureChecksByIDs mocks base method.
func (m *MockStore) GetPostureChecksByIDs(ctx context.Context, lockStrength LockingStrength, accountID string, postureChecksIDs []string) (map[string]*posture.Checks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPostureChecksByIDs", ctx, lockStrength, accountID, postureChecksIDs)
	ret0, _ := ret[0].(map[string]*posture.Checks)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProxyAccessTokenByHashedToken mocks base method.
func (m *MockStore) GetProxyAccessTokenByHashedToken(ctx context.Context, lockStrength LockingStrength, hashedToken types2.HashedProxyToken) (*types2.ProxyAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProxyAccessTokenByHashedToken", ctx, lockStrength, hashedToken)
	ret0, _ := ret[0].(*types2.ProxyAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetResourceGroups mocks base method.
func (m *MockStore) GetResourceGroups(ctx context.Context, lockStrength LockingStrength, accountID, resourceID string) ([]*types2.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResourceGroups", ctx, lockStrength, accountID, resourceID)
	ret0, _ := ret[0].([]*types2.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRouteByID mocks base method.
func (m *MockStore) GetRouteByID(ctx context.Context, lockStrength LockingStrength, accountID, routeID string) (*route.Route, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRouteByID", ctx, lockStrength, accountID, routeID)
	ret0, _ := ret[0].(*route.Route)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetServiceByID mocks base method.
func (m *MockStore) GetServiceByID(ctx context.Context, lockStrength LockingStrength, accountID, serviceID string) (*service.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceByID", ctx, lockStrength, accountID, serviceID)
	ret0, _ := ret[0].(*service.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetServiceTargetByTargetID mocks base method.
func (m *MockStore) GetServiceTargetByTargetID(ctx context.Context, lockStrength LockingStrength, accountID, targetID string) (*service.Target, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceTargetByTargetID", ctx, lockStrength, accountID, targetID)
	ret0, _ := ret[0].(*service.Target)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetServices mocks base method.
func (m *MockStore) GetServices(ctx context.Context, lockStrength LockingStrength) ([]*service.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServices", ctx, lockStrength)
	ret0, _ := ret[0].([]*service.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetServicesByCluster mocks base method.
func (m *MockStore) GetServicesByCluster(ctx context.Context, lockStrength LockingStrength, proxyCluster string) ([]*service.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServicesByCluster", ctx, lockStrength, proxyCluster)
	ret0, _ := ret[0].([]*service.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetServicesByClusterAndPort mocks base method.
func (m *MockStore) GetServicesByClusterAndPort(ctx context.Context, lockStrength LockingStrength, proxyCluster, mode string, listenPort uint16) ([]*service.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServicesByClusterAndPort", ctx, lockStrength, proxyCluster, mode, listenPort)
	ret0, _ := ret[0].([]*service.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServicesByClusterAndPort indicates an expected call of GetServicesByClusterAndPort.
func (mr *MockStoreMockRecorder) GetServicesByClusterAndPort(ctx, lockStrength, proxyCluster, mode, listenPort interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicesByClusterAndPort", reflect.TypeOf((*MockStore)(nil).GetServicesByClusterAndPort), ctx, lockStrength, proxyCluster, mode, listenPort)
}

// GetSetupKeyByID mocks base method.
func (m *MockStore) GetSetupKeyByID(ctx context.Context, lockStrength LockingStrength, accountID, setupKeyID string) (*types2.SetupKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSetupKeyByID", ctx, lockStrength, accountID, setupKeyID)
	ret0, _ := ret[0].(*types2.SetupKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSetupKeyBySecret mocks base method.
func (m *MockStore) GetSetupKeyBySecret(ctx context.Context, lockStrength LockingStrength, key string) (*types2.SetupKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSetupKeyBySecret", ctx, lockStrength, key)
	ret0, _ := ret[0].(*types2.SetupKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetTakenIPs mocks base method.
func (m *MockStore) GetTakenIPs(ctx context.Context, lockStrength LockingStrength, accountId string) ([]net.IP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTakenIPs", ctx, lockStrength, accountId)
	ret0, _ := ret[0].([]net.IP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTargetsByServiceID mocks base method.
func (m *MockStore) GetTargetsByServiceID(ctx context.Context, lockStrength LockingStrength, accountID, serviceID string) ([]*service.Target, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTargetsByServiceID", ctx, lockStrength, accountID, serviceID)
	ret0, _ := ret[0].([]*service.Target)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetUserByPATID mocks base method.
func (m *MockStore) GetUserByPATID(ctx context.Context, lockStrength LockingStrength, patID string) (*types2.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByPATID", ctx, lockStrength, patID)
	ret0, _ := ret[0].(*types2.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserByUserID mocks base method.
func (m *MockStore) GetUserByUserID(ctx context.Context, lockStrength LockingStrength, userID string) (*types2.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByUserID", ctx, lockStrength, userID)
	ret0, _ := ret[0].(*types2.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetUserInviteByEmail mocks base method.
func (m *MockStore) GetUserInviteByEmail(ctx context.Context, lockStrength LockingStrength, accountID, email string) (*types2.UserInviteRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserInviteByEmail", ctx, lockStrength, accountID, email)
	ret0, _ := ret[0].(*types2.UserInviteRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserInviteByHashedToken mocks base method.
func (m *MockStore) GetUserInviteByHashedToken(ctx context.Context, lockStrength LockingStrength, hashedToken string) (*types2.UserInviteRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserInviteByHashedToken", ctx, lockStrength, hashedToken)
	ret0, _ := ret[0].(*types2.UserInviteRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserInviteByID mocks base method.
func (m *MockStore) GetUserInviteByID(ctx context.Context, lockStrength LockingStrength, accountID, inviteID string) (*types2.UserInviteRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserInviteByID", ctx, lockStrength, accountID, inviteID)
	ret0, _ := ret[0].(*types2.UserInviteRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserPATs mocks base method.
func (m *MockStore) GetUserPATs(ctx context.Context, lockStrength LockingStrength, userID string) ([]*types2.PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserPATs", ctx, lockStrength, userID)
	ret0, _ := ret[0].([]*types2.PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserPeers mocks base method.
func (m *MockStore) GetUserPeers(ctx context.Context, lockStrength LockingStrength, accountID, userID string) ([]*peer.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserPeers", ctx, lockStrength, accountID, userID)
	ret0, _ := ret[0].([]*peer.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetZoneByID mocks base method.
func (m *MockStore) GetZoneByID(ctx context.Context, lockStrength LockingStrength, accountID, zoneID string) (*zones.Zone, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetZoneByID", ctx, lockStrength, accountID, zoneID)
	ret0, _ := ret[0].(*zones.Zone)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetZoneDNSRecords mocks base method.
func (m *MockStore) GetZoneDNSRecords(ctx context.Context, lockStrength LockingStrength, accountID, zoneID string) ([]*records.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetZoneDNSRecords", ctx, lockStrength, accountID, zoneID)
	ret0, _ := ret[0].([]*records.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetZoneDNSRecordsByName mocks base method.
func (m *MockStore) GetZoneDNSRecordsByName(ctx context.Context, lockStrength LockingStrength, accountID, zoneID, name string) ([]*records.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetZoneDNSRecordsByName", ctx, lockStrength, accountID, zoneID, name)
	ret0, _ := ret[0].([]*records.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MarkPendingJobsAsFailed mocks base method.
func (m *MockStore) MarkPendingJobsAsFailed(ctx context.Context, accountID, peerID, jobID, reason string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkPendingJobsAsFailed", ctx, accountID, peerID, jobID, reason)
	ret0, _ := ret[0].(error)
	return ret0
}

// MarkPendingJobsAsFailed indicates an expected call of MarkPendingJobsAsFailed.
func (mr *MockStoreMockRecorder) MarkPendingJobsAsFailed(ctx, accountID, peerID, jobID, reason interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkPendingJobsAsFailed", reflect.TypeOf((*MockStore)(nil).MarkPendingJobsAsFailed), ctx, accountID, peerID, jobID, reason)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SaveAccountSettings mocks base method.
func (m *MockStore) SaveAccountSettings(ctx context.Context, accountID string, settings *types2.Settings) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveAccountSettings", ctx, accountID, settings)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SaveDNSSettings mocks base method.
func (m *MockStore) SaveDNSSettings(ctx context.Context, accountID string, settings *types2.DNSSettings) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveDNSSettings", ctx, accountID, settings)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SavePeerStatus mocks base method.
func (m *MockStore) SavePeerStatus(ctx context.Context, accountID, peerID string, status peer.PeerStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SavePeerStatus", ctx, accountID, peerID, status)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SaveUserLastLogin mocks base method.
func (m *MockStore) SaveUserLastLogin(ctx context.Context, accountID, userID string, lastLogin time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveUserLastLogin", ctx, accountID, userID, lastLogin)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// SetFieldEncrypt mocks base method.
func (m *MockStore) SetFieldEncrypt(enc *crypt.FieldEncrypt) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFieldEncrypt", enc)
}

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

// UpdateAccountDomainAttributes mocks base method.
func (m *MockStore) UpdateAccountDomainAttributes(ctx context.Context, accountID, domain, category string, isPrimaryDomain bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountDomainAttributes", ctx, accountID, domain, category, isPrimaryDomain)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateAccountDomainAttributes indicates an expected call of UpdateAccountDomainAttributes.
func (mr *MockStoreMockRecorder) UpdateAccountDomainAttributes(ctx, accountID, domain, category, isPrimaryDomain interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccountDomainAttributes", reflect.TypeOf((*MockStore)(nil).UpdateAccountDomainAttributes), ctx, accountID, domain, category, isPrimaryDomain)
}

// UpdateAccountNetwork mocks base method.
func (m *MockStore) UpdateAccountNetwork(ctx context.Context, accountID string, ipNet net.IPNet) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountNetwork", ctx, accountID, ipNet)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

// UpdateGroups mocks base method.
func (m *MockStore) UpdateGroups(ctx context.Context, accountID string, groups []*types2.Group) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGroups", ctx, accountID, groups)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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