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

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

import (
	context "context"
	net "net"
	netip "net/netip"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	dns "github.com/netbirdio/netbird/dns"
	service "github.com/netbirdio/netbird/management/internals/modules/reverseproxy/service"
	activity "github.com/netbirdio/netbird/management/server/activity"
	affectedpeers "github.com/netbirdio/netbird/management/server/affectedpeers"
	idp "github.com/netbirdio/netbird/management/server/idp"
	peer "github.com/netbirdio/netbird/management/server/peer"
	posture "github.com/netbirdio/netbird/management/server/posture"
	store "github.com/netbirdio/netbird/management/server/store"
	types "github.com/netbirdio/netbird/management/server/types"
	users "github.com/netbirdio/netbird/management/server/users"
	route "github.com/netbirdio/netbird/route"
	auth "github.com/netbirdio/netbird/shared/auth"
	domain "github.com/netbirdio/netbird/shared/management/domain"
)

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

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

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

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

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

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

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

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

// AddPeer mocks base method.
func (m *MockManager) AddPeer(ctx context.Context, accountID, setupKey, userID string, p *peer.Peer, temporary bool) (*peer.Peer, *types.NetworkMap, []*posture.Checks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPeer", ctx, accountID, setupKey, userID, p, temporary)
	ret0, _ := ret[0].(*peer.Peer)
	ret1, _ := ret[1].(*types.NetworkMap)
	ret2, _ := ret[2].([]*posture.Checks)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// AddPeer indicates an expected call of AddPeer.
func (mr *MockManagerMockRecorder) AddPeer(ctx, accountID, setupKey, userID, p, temporary interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPeer", reflect.TypeOf((*MockManager)(nil).AddPeer), ctx, accountID, setupKey, userID, p, temporary)
}

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

// ApproveUser indicates an expected call of ApproveUser.
func (mr *MockManagerMockRecorder) ApproveUser(ctx, accountID, initiatorUserID, targetUserID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveUser", reflect.TypeOf((*MockManager)(nil).ApproveUser), ctx, accountID, initiatorUserID, targetUserID)
}

// BufferUpdateAccountPeers mocks base method.
func (m *MockManager) BufferUpdateAccountPeers(ctx context.Context, accountID string, reason types.UpdateReason) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BufferUpdateAccountPeers", ctx, accountID, reason)
}

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

// BuildUserInfosForAccount mocks base method.
func (m *MockManager) BuildUserInfosForAccount(ctx context.Context, accountID, initiatorUserID string, accountUsers []*types.User) (map[string]*types.UserInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildUserInfosForAccount", ctx, accountID, initiatorUserID, accountUsers)
	ret0, _ := ret[0].(map[string]*types.UserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildUserInfosForAccount indicates an expected call of BuildUserInfosForAccount.
func (mr *MockManagerMockRecorder) BuildUserInfosForAccount(ctx, accountID, initiatorUserID, accountUsers interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildUserInfosForAccount", reflect.TypeOf((*MockManager)(nil).BuildUserInfosForAccount), ctx, accountID, initiatorUserID, accountUsers)
}

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

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

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

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

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

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

// CreateNameServerGroup mocks base method.
func (m *MockManager) CreateNameServerGroup(ctx context.Context, accountID, name, description string, nameServerList []dns.NameServer, groups []string, primary bool, domains []string, enabled bool, userID string, searchDomainsEnabled bool) (*dns.NameServerGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNameServerGroup", ctx, accountID, name, description, nameServerList, groups, primary, domains, enabled, userID, searchDomainsEnabled)
	ret0, _ := ret[0].(*dns.NameServerGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNameServerGroup indicates an expected call of CreateNameServerGroup.
func (mr *MockManagerMockRecorder) CreateNameServerGroup(ctx, accountID, name, description, nameServerList, groups, primary, domains, enabled, userID, searchDomainsEnabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNameServerGroup", reflect.TypeOf((*MockManager)(nil).CreateNameServerGroup), ctx, accountID, name, description, nameServerList, groups, primary, domains, enabled, userID, searchDomainsEnabled)
}

// CreatePAT mocks base method.
func (m *MockManager) CreatePAT(ctx context.Context, accountID, initiatorUserID, targetUserID, tokenName string, expiresIn int) (*types.PersonalAccessTokenGenerated, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePAT", ctx, accountID, initiatorUserID, targetUserID, tokenName, expiresIn)
	ret0, _ := ret[0].(*types.PersonalAccessTokenGenerated)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePAT indicates an expected call of CreatePAT.
func (mr *MockManagerMockRecorder) CreatePAT(ctx, accountID, initiatorUserID, targetUserID, tokenName, expiresIn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePAT", reflect.TypeOf((*MockManager)(nil).CreatePAT), ctx, accountID, initiatorUserID, targetUserID, tokenName, expiresIn)
}

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

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

// CreateRoute mocks base method.
func (m *MockManager) CreateRoute(ctx context.Context, accountID string, prefix netip.Prefix, networkType route.NetworkType, domains domain.List, peerID string, peerGroupIDs []string, description string, netID route.NetID, masquerade bool, metric int, groups, accessControlGroupIDs []string, enabled bool, userID string, keepRoute, skipAutoApply bool) (*route.Route, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRoute", ctx, accountID, prefix, networkType, domains, peerID, peerGroupIDs, description, netID, masquerade, metric, groups, accessControlGroupIDs, enabled, userID, keepRoute, skipAutoApply)
	ret0, _ := ret[0].(*route.Route)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRoute indicates an expected call of CreateRoute.
func (mr *MockManagerMockRecorder) CreateRoute(ctx, accountID, prefix, networkType, domains, peerID, peerGroupIDs, description, netID, masquerade, metric, groups, accessControlGroupIDs, enabled, userID, keepRoute, skipAutoApply interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockManager)(nil).CreateRoute), ctx, accountID, prefix, networkType, domains, peerID, peerGroupIDs, description, netID, masquerade, metric, groups, accessControlGroupIDs, enabled, userID, keepRoute, skipAutoApply)
}

// CreateSetupKey mocks base method.
func (m *MockManager) CreateSetupKey(ctx context.Context, accountID, keyName string, keyType types.SetupKeyType, expiresIn time.Duration, autoGroups []string, usageLimit int, userID string, ephemeral, allowExtraDNSLabels bool) (*types.SetupKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSetupKey", ctx, accountID, keyName, keyType, expiresIn, autoGroups, usageLimit, userID, ephemeral, allowExtraDNSLabels)
	ret0, _ := ret[0].(*types.SetupKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSetupKey indicates an expected call of CreateSetupKey.
func (mr *MockManagerMockRecorder) CreateSetupKey(ctx, accountID, keyName, keyType, expiresIn, autoGroups, usageLimit, userID, ephemeral, allowExtraDNSLabels interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSetupKey", reflect.TypeOf((*MockManager)(nil).CreateSetupKey), ctx, accountID, keyName, keyType, expiresIn, autoGroups, usageLimit, userID, ephemeral, allowExtraDNSLabels)
}

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

// CreateUser indicates an expected call of CreateUser.
func (mr *MockManagerMockRecorder) CreateUser(ctx, accountID, initiatorUserID, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUser", reflect.TypeOf((*MockManager)(nil).CreateUser), ctx, accountID, initiatorUserID, key)
}

// CreateUserInvite mocks base method.
func (m *MockManager) CreateUserInvite(ctx context.Context, accountID, initiatorUserID string, invite *types.UserInfo, expiresIn int) (*types.UserInvite, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUserInvite", ctx, accountID, initiatorUserID, invite, expiresIn)
	ret0, _ := ret[0].(*types.UserInvite)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateUserInvite indicates an expected call of CreateUserInvite.
func (mr *MockManagerMockRecorder) CreateUserInvite(ctx, accountID, initiatorUserID, invite, expiresIn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserInvite", reflect.TypeOf((*MockManager)(nil).CreateUserInvite), ctx, accountID, initiatorUserID, invite, expiresIn)
}

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

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

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

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

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

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

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

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

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

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

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

// DeletePAT indicates an expected call of DeletePAT.
func (mr *MockManagerMockRecorder) DeletePAT(ctx, accountID, initiatorUserID, targetUserID, tokenID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePAT", reflect.TypeOf((*MockManager)(nil).DeletePAT), ctx, accountID, initiatorUserID, targetUserID, tokenID)
}

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

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

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

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

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

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

// DeleteRegularUsers mocks base method.
func (m *MockManager) DeleteRegularUsers(ctx context.Context, accountID, initiatorUserID string, targetUserIDs []string, userInfos map[string]*types.UserInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRegularUsers", ctx, accountID, initiatorUserID, targetUserIDs, userInfos)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRegularUsers indicates an expected call of DeleteRegularUsers.
func (mr *MockManagerMockRecorder) DeleteRegularUsers(ctx, accountID, initiatorUserID, targetUserIDs, userInfos interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegularUsers", reflect.TypeOf((*MockManager)(nil).DeleteRegularUsers), ctx, accountID, initiatorUserID, targetUserIDs, userInfos)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetAllPATs indicates an expected call of GetAllPATs.
func (mr *MockManagerMockRecorder) GetAllPATs(ctx, accountID, initiatorUserID, targetUserID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllPATs", reflect.TypeOf((*MockManager)(nil).GetAllPATs), ctx, accountID, initiatorUserID, targetUserID)
}

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

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

// GetCurrentUserInfo mocks base method.
func (m *MockManager) GetCurrentUserInfo(ctx context.Context, userAuth auth.UserAuth) (*users.UserInfoWithPermissions, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentUserInfo", ctx, userAuth)
	ret0, _ := ret[0].(*users.UserInfoWithPermissions)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// GetGroup mocks base method.
func (m *MockManager) GetGroup(ctx context.Context, accountId, groupID, userID string) (*types.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroup", ctx, accountId, groupID, userID)
	ret0, _ := ret[0].(*types.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroup indicates an expected call of GetGroup.
func (mr *MockManagerMockRecorder) GetGroup(ctx, accountId, groupID, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroup", reflect.TypeOf((*MockManager)(nil).GetGroup), ctx, accountId, groupID, userID)
}

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

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

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

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

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

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

// GetIdpManager mocks base method.
func (m *MockManager) GetIdpManager() idp.Manager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIdpManager")
	ret0, _ := ret[0].(idp.Manager)
	return ret0
}

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

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

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

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

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

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

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

// GetOrCreateAccountByUser mocks base method.
func (m *MockManager) GetOrCreateAccountByUser(ctx context.Context, userAuth auth.UserAuth) (*types.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrCreateAccountByUser", ctx, userAuth)
	ret0, _ := ret[0].(*types.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetPAT mocks base method.
func (m *MockManager) GetPAT(ctx context.Context, accountID, initiatorUserID, targetUserID, tokenID string) (*types.PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPAT", ctx, accountID, initiatorUserID, targetUserID, tokenID)
	ret0, _ := ret[0].(*types.PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPAT indicates an expected call of GetPAT.
func (mr *MockManagerMockRecorder) GetPAT(ctx, accountID, initiatorUserID, targetUserID, tokenID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPAT", reflect.TypeOf((*MockManager)(nil).GetPAT), ctx, accountID, initiatorUserID, targetUserID, tokenID)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetStore mocks base method.
func (m *MockManager) GetStore() store.Store {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStore")
	ret0, _ := ret[0].(store.Store)
	return ret0
}

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

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

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

// GetUserFromUserAuth mocks base method.
func (m *MockManager) GetUserFromUserAuth(ctx context.Context, userAuth auth.UserAuth) (*types.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserFromUserAuth", ctx, userAuth)
	ret0, _ := ret[0].(*types.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InviteUser indicates an expected call of InviteUser.
func (mr *MockManagerMockRecorder) InviteUser(ctx, accountID, initiatorUserID, targetUserID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteUser", reflect.TypeOf((*MockManager)(nil).InviteUser), ctx, accountID, initiatorUserID, targetUserID)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// LoginPeer mocks base method.
func (m *MockManager) LoginPeer(ctx context.Context, login types.PeerLogin) (*peer.Peer, *types.NetworkMap, []*posture.Checks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoginPeer", ctx, login)
	ret0, _ := ret[0].(*peer.Peer)
	ret1, _ := ret[1].(*types.NetworkMap)
	ret2, _ := ret[2].([]*posture.Checks)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

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

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

// MarkPeerConnected mocks base method.
func (m *MockManager) MarkPeerConnected(ctx context.Context, peerKey string, realIP net.IP, accountID string, sessionStartedAt int64, nmap *types.NetworkMap) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkPeerConnected", ctx, peerKey, realIP, accountID, sessionStartedAt, nmap)
	ret0, _ := ret[0].(error)
	return ret0
}

// MarkPeerConnected indicates an expected call of MarkPeerConnected.
func (mr *MockManagerMockRecorder) MarkPeerConnected(ctx, peerKey, realIP, accountID, sessionStartedAt, nmap interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkPeerConnected", reflect.TypeOf((*MockManager)(nil).MarkPeerConnected), ctx, peerKey, realIP, accountID, sessionStartedAt, nmap)
}

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

// MarkPeerDisconnected indicates an expected call of MarkPeerDisconnected.
func (mr *MockManagerMockRecorder) MarkPeerDisconnected(ctx, peerKey, accountID, sessionStartedAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkPeerDisconnected", reflect.TypeOf((*MockManager)(nil).MarkPeerDisconnected), ctx, peerKey, accountID, sessionStartedAt)
}

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

// OnPeerDisconnected indicates an expected call of OnPeerDisconnected.
func (mr *MockManagerMockRecorder) OnPeerDisconnected(ctx, accountID, peerPubKey, streamStartTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPeerDisconnected", reflect.TypeOf((*MockManager)(nil).OnPeerDisconnected), ctx, accountID, peerPubKey, streamStartTime)
}

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

// RegenerateUserInvite indicates an expected call of RegenerateUserInvite.
func (mr *MockManagerMockRecorder) RegenerateUserInvite(ctx, accountID, initiatorUserID, inviteID, expiresIn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegenerateUserInvite", reflect.TypeOf((*MockManager)(nil).RegenerateUserInvite), ctx, accountID, initiatorUserID, inviteID, expiresIn)
}

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

// RejectUser indicates an expected call of RejectUser.
func (mr *MockManagerMockRecorder) RejectUser(ctx, accountID, initiatorUserID, targetUserID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectUser", reflect.TypeOf((*MockManager)(nil).RejectUser), ctx, accountID, initiatorUserID, targetUserID)
}

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

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

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

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

// SaveOrAddUser mocks base method.
func (m *MockManager) SaveOrAddUser(ctx context.Context, accountID, initiatorUserID string, update *types.User, addIfNotExists bool) (*types.UserInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveOrAddUser", ctx, accountID, initiatorUserID, update, addIfNotExists)
	ret0, _ := ret[0].(*types.UserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveOrAddUser indicates an expected call of SaveOrAddUser.
func (mr *MockManagerMockRecorder) SaveOrAddUser(ctx, accountID, initiatorUserID, update, addIfNotExists interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveOrAddUser", reflect.TypeOf((*MockManager)(nil).SaveOrAddUser), ctx, accountID, initiatorUserID, update, addIfNotExists)
}

// SaveOrAddUsers mocks base method.
func (m *MockManager) SaveOrAddUsers(ctx context.Context, accountID, initiatorUserID string, updates []*types.User, addIfNotExists bool) ([]*types.UserInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveOrAddUsers", ctx, accountID, initiatorUserID, updates, addIfNotExists)
	ret0, _ := ret[0].([]*types.UserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveOrAddUsers indicates an expected call of SaveOrAddUsers.
func (mr *MockManagerMockRecorder) SaveOrAddUsers(ctx, accountID, initiatorUserID, updates, addIfNotExists interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveOrAddUsers", reflect.TypeOf((*MockManager)(nil).SaveOrAddUsers), ctx, accountID, initiatorUserID, updates, addIfNotExists)
}

// SavePolicy mocks base method.
func (m *MockManager) SavePolicy(ctx context.Context, accountID, userID string, policy *types.Policy, create bool) (*types.Policy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SavePolicy", ctx, accountID, userID, policy, create)
	ret0, _ := ret[0].(*types.Policy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SavePostureChecks mocks base method.
func (m *MockManager) SavePostureChecks(ctx context.Context, accountID, userID string, postureChecks *posture.Checks, create bool) (*posture.Checks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SavePostureChecks", ctx, accountID, userID, postureChecks, create)
	ret0, _ := ret[0].(*posture.Checks)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SavePostureChecks indicates an expected call of SavePostureChecks.
func (mr *MockManagerMockRecorder) SavePostureChecks(ctx, accountID, userID, postureChecks, create interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SavePostureChecks", reflect.TypeOf((*MockManager)(nil).SavePostureChecks), ctx, accountID, userID, postureChecks, create)
}

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

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

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

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

// SaveUser mocks base method.
func (m *MockManager) SaveUser(ctx context.Context, accountID, initiatorUserID string, update *types.User) (*types.UserInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveUser", ctx, accountID, initiatorUserID, update)
	ret0, _ := ret[0].(*types.UserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveUser indicates an expected call of SaveUser.
func (mr *MockManagerMockRecorder) SaveUser(ctx, accountID, initiatorUserID, update interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveUser", reflect.TypeOf((*MockManager)(nil).SaveUser), ctx, accountID, initiatorUserID, update)
}

// SetServiceManager mocks base method.
func (m *MockManager) SetServiceManager(serviceManager service.Manager) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetServiceManager", serviceManager)
}

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

// StoreEvent mocks base method.
func (m *MockManager) StoreEvent(ctx context.Context, initiatorID, targetID, accountID string, activityID activity.ActivityDescriber, meta map[string]any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StoreEvent", ctx, initiatorID, targetID, accountID, activityID, meta)
}

// StoreEvent indicates an expected call of StoreEvent.
func (mr *MockManagerMockRecorder) StoreEvent(ctx, initiatorID, targetID, accountID, activityID, meta interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreEvent", reflect.TypeOf((*MockManager)(nil).StoreEvent), ctx, initiatorID, targetID, accountID, activityID, meta)
}

// SyncAndMarkPeer mocks base method.
func (m *MockManager) SyncAndMarkPeer(ctx context.Context, accountID, peerPubKey string, meta peer.PeerSystemMeta, realIP net.IP, syncTime time.Time) (*peer.Peer, *types.NetworkMap, []*posture.Checks, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncAndMarkPeer", ctx, accountID, peerPubKey, meta, realIP, syncTime)
	ret0, _ := ret[0].(*peer.Peer)
	ret1, _ := ret[1].(*types.NetworkMap)
	ret2, _ := ret[2].([]*posture.Checks)
	ret3, _ := ret[3].(int64)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

// SyncAndMarkPeer indicates an expected call of SyncAndMarkPeer.
func (mr *MockManagerMockRecorder) SyncAndMarkPeer(ctx, accountID, peerPubKey, meta, realIP, syncTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncAndMarkPeer", reflect.TypeOf((*MockManager)(nil).SyncAndMarkPeer), ctx, accountID, peerPubKey, meta, realIP, syncTime)
}

// SyncPeer mocks base method.
func (m *MockManager) SyncPeer(ctx context.Context, sync types.PeerSync, accountID string) (*peer.Peer, *types.NetworkMap, []*posture.Checks, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncPeer", ctx, sync, accountID)
	ret0, _ := ret[0].(*peer.Peer)
	ret1, _ := ret[1].(*types.NetworkMap)
	ret2, _ := ret[2].([]*posture.Checks)
	ret3, _ := ret[3].(int64)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

// SyncPeerMeta mocks base method.
func (m *MockManager) SyncPeerMeta(ctx context.Context, peerPubKey string, meta peer.PeerSystemMeta) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncPeerMeta", ctx, peerPubKey, meta)
	ret0, _ := ret[0].(error)
	return ret0
}

// SyncPeerMeta indicates an expected call of SyncPeerMeta.
func (mr *MockManagerMockRecorder) SyncPeerMeta(ctx, peerPubKey, meta interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPeerMeta", reflect.TypeOf((*MockManager)(nil).SyncPeerMeta), ctx, peerPubKey, meta)
}

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

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

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

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

// UpdateAccountPeers mocks base method.
func (m *MockManager) UpdateAccountPeers(ctx context.Context, accountID string, reason types.UpdateReason) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateAccountPeers", ctx, accountID, reason)
}

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

// ExpandAndUpdateAffected mocks base method.
func (m *MockManager) ExpandAndUpdateAffected(ctx context.Context, accountID string, snap *affectedpeers.Snapshot, change affectedpeers.Change) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ExpandAndUpdateAffected", ctx, accountID, snap, change)
}

// ExpandAndUpdateAffected indicates an expected call of ExpandAndUpdateAffected.
func (mr *MockManagerMockRecorder) ExpandAndUpdateAffected(ctx, accountID, snap, change interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpandAndUpdateAffected", reflect.TypeOf((*MockManager)(nil).ExpandAndUpdateAffected), ctx, accountID, snap, change)
}

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

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

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

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

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

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

// UpdateIdentityProvider mocks base method.
func (m *MockManager) UpdateIdentityProvider(ctx context.Context, accountID, idpID, userID string, idp *types.IdentityProvider) (*types.IdentityProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIdentityProvider", ctx, accountID, idpID, userID, idp)
	ret0, _ := ret[0].(*types.IdentityProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateIdentityProvider indicates an expected call of UpdateIdentityProvider.
func (mr *MockManagerMockRecorder) UpdateIdentityProvider(ctx, accountID, idpID, userID, idp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIdentityProvider", reflect.TypeOf((*MockManager)(nil).UpdateIdentityProvider), ctx, accountID, idpID, userID, idp)
}

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

// UpdateIntegratedValidator indicates an expected call of UpdateIntegratedValidator.
func (mr *MockManagerMockRecorder) UpdateIntegratedValidator(ctx, accountID, userID, validator, groups interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIntegratedValidator", reflect.TypeOf((*MockManager)(nil).UpdateIntegratedValidator), ctx, accountID, userID, validator, groups)
}

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

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

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

// UpdatePeerIP indicates an expected call of UpdatePeerIP.
func (mr *MockManagerMockRecorder) UpdatePeerIP(ctx, accountID, userID, peerID, newIP interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePeerIP", reflect.TypeOf((*MockManager)(nil).UpdatePeerIP), ctx, accountID, userID, peerID, newIP)
}

func (m *MockManager) UpdatePeerIPv6(ctx context.Context, accountID, userID, peerID string, newIPv6 netip.Addr) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePeerIPv6", ctx, accountID, userID, peerID, newIPv6)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockManagerMockRecorder) UpdatePeerIPv6(ctx, accountID, userID, peerID, newIPv6 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePeerIPv6", reflect.TypeOf((*MockManager)(nil).UpdatePeerIPv6), ctx, accountID, userID, peerID, newIPv6)
}

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

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

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

// UpdateUserPassword indicates an expected call of UpdateUserPassword.
func (mr *MockManagerMockRecorder) UpdateUserPassword(ctx, accountID, currentUserID, targetUserID, oldPassword, newPassword interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPassword", reflect.TypeOf((*MockManager)(nil).UpdateUserPassword), ctx, accountID, currentUserID, targetUserID, oldPassword, newPassword)
}
