// Copyright (c) Abstract Machines

// SPDX-License-Identifier: Apache-2.0

// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	"github.com/absmach/magistrala/api/grpc/token/v1"
	"github.com/absmach/magistrala/pkg/authn"
	"github.com/absmach/magistrala/users"
	mock "github.com/stretchr/testify/mock"
)

// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewService(t interface {
	mock.TestingT
	Cleanup(func())
}) *Service {
	mock := &Service{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// Service is an autogenerated mock type for the Service type
type Service struct {
	mock.Mock
}

type Service_Expecter struct {
	mock *mock.Mock
}

func (_m *Service) EXPECT() *Service_Expecter {
	return &Service_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function for the type Service
func (_mock *Service) Delete(ctx context.Context, session authn.Session, id string) error {
	ret := _mock.Called(ctx, session, id)

	if len(ret) == 0 {
		panic("no return value specified for Delete")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) error); ok {
		r0 = returnFunc(ctx, session, id)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Service_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
type Service_Delete_Call struct {
	*mock.Call
}

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
func (_e *Service_Expecter) Delete(ctx interface{}, session interface{}, id interface{}) *Service_Delete_Call {
	return &Service_Delete_Call{Call: _e.mock.On("Delete", ctx, session, id)}
}

func (_c *Service_Delete_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_Delete_Call) Return(err error) *Service_Delete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_Delete_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) error) *Service_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// Disable provides a mock function for the type Service
func (_mock *Service) Disable(ctx context.Context, session authn.Session, id string) (users.User, error) {
	ret := _mock.Called(ctx, session, id)

	if len(ret) == 0 {
		panic("no return value specified for Disable")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (users.User, error)); ok {
		return returnFunc(ctx, session, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) users.User); ok {
		r0 = returnFunc(ctx, session, id)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok {
		r1 = returnFunc(ctx, session, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_Disable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disable'
type Service_Disable_Call struct {
	*mock.Call
}

// Disable is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
func (_e *Service_Expecter) Disable(ctx interface{}, session interface{}, id interface{}) *Service_Disable_Call {
	return &Service_Disable_Call{Call: _e.mock.On("Disable", ctx, session, id)}
}

func (_c *Service_Disable_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_Disable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_Disable_Call) Return(user users.User, err error) *Service_Disable_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_Disable_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) (users.User, error)) *Service_Disable_Call {
	_c.Call.Return(run)
	return _c
}

// Enable provides a mock function for the type Service
func (_mock *Service) Enable(ctx context.Context, session authn.Session, id string) (users.User, error) {
	ret := _mock.Called(ctx, session, id)

	if len(ret) == 0 {
		panic("no return value specified for Enable")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (users.User, error)); ok {
		return returnFunc(ctx, session, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) users.User); ok {
		r0 = returnFunc(ctx, session, id)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok {
		r1 = returnFunc(ctx, session, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_Enable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Enable'
type Service_Enable_Call struct {
	*mock.Call
}

// Enable is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
func (_e *Service_Expecter) Enable(ctx interface{}, session interface{}, id interface{}) *Service_Enable_Call {
	return &Service_Enable_Call{Call: _e.mock.On("Enable", ctx, session, id)}
}

func (_c *Service_Enable_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_Enable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_Enable_Call) Return(user users.User, err error) *Service_Enable_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_Enable_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) (users.User, error)) *Service_Enable_Call {
	_c.Call.Return(run)
	return _c
}

// Identify provides a mock function for the type Service
func (_mock *Service) Identify(ctx context.Context, session authn.Session) (string, error) {
	ret := _mock.Called(ctx, session)

	if len(ret) == 0 {
		panic("no return value specified for Identify")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) (string, error)); ok {
		return returnFunc(ctx, session)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) string); ok {
		r0 = returnFunc(ctx, session)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session) error); ok {
		r1 = returnFunc(ctx, session)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_Identify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Identify'
type Service_Identify_Call struct {
	*mock.Call
}

// Identify is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
func (_e *Service_Expecter) Identify(ctx interface{}, session interface{}) *Service_Identify_Call {
	return &Service_Identify_Call{Call: _e.mock.On("Identify", ctx, session)}
}

func (_c *Service_Identify_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_Identify_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_Identify_Call) Return(s string, err error) *Service_Identify_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *Service_Identify_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) (string, error)) *Service_Identify_Call {
	_c.Call.Return(run)
	return _c
}

// IssueToken provides a mock function for the type Service
func (_mock *Service) IssueToken(ctx context.Context, identity string, secret string, description string) (*v1.Token, error) {
	ret := _mock.Called(ctx, identity, secret, description)

	if len(ret) == 0 {
		panic("no return value specified for IssueToken")
	}

	var r0 *v1.Token
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*v1.Token, error)); ok {
		return returnFunc(ctx, identity, secret, description)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *v1.Token); ok {
		r0 = returnFunc(ctx, identity, secret, description)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1.Token)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, identity, secret, description)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_IssueToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueToken'
type Service_IssueToken_Call struct {
	*mock.Call
}

// IssueToken is a helper method to define mock.On call
//   - ctx context.Context
//   - identity string
//   - secret string
//   - description string
func (_e *Service_Expecter) IssueToken(ctx interface{}, identity interface{}, secret interface{}, description interface{}) *Service_IssueToken_Call {
	return &Service_IssueToken_Call{Call: _e.mock.On("IssueToken", ctx, identity, secret, description)}
}

func (_c *Service_IssueToken_Call) Run(run func(ctx context.Context, identity string, secret string, description string)) *Service_IssueToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_IssueToken_Call) Return(token *v1.Token, err error) *Service_IssueToken_Call {
	_c.Call.Return(token, err)
	return _c
}

func (_c *Service_IssueToken_Call) RunAndReturn(run func(ctx context.Context, identity string, secret string, description string) (*v1.Token, error)) *Service_IssueToken_Call {
	_c.Call.Return(run)
	return _c
}

// ListActiveRefreshTokens provides a mock function for the type Service
func (_mock *Service) ListActiveRefreshTokens(ctx context.Context, session authn.Session) (*v1.ListUserRefreshTokensRes, error) {
	ret := _mock.Called(ctx, session)

	if len(ret) == 0 {
		panic("no return value specified for ListActiveRefreshTokens")
	}

	var r0 *v1.ListUserRefreshTokensRes
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) (*v1.ListUserRefreshTokensRes, error)); ok {
		return returnFunc(ctx, session)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) *v1.ListUserRefreshTokensRes); ok {
		r0 = returnFunc(ctx, session)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1.ListUserRefreshTokensRes)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session) error); ok {
		r1 = returnFunc(ctx, session)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_ListActiveRefreshTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActiveRefreshTokens'
type Service_ListActiveRefreshTokens_Call struct {
	*mock.Call
}

// ListActiveRefreshTokens is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
func (_e *Service_Expecter) ListActiveRefreshTokens(ctx interface{}, session interface{}) *Service_ListActiveRefreshTokens_Call {
	return &Service_ListActiveRefreshTokens_Call{Call: _e.mock.On("ListActiveRefreshTokens", ctx, session)}
}

func (_c *Service_ListActiveRefreshTokens_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_ListActiveRefreshTokens_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ListActiveRefreshTokens_Call) Return(listUserRefreshTokensRes *v1.ListUserRefreshTokensRes, err error) *Service_ListActiveRefreshTokens_Call {
	_c.Call.Return(listUserRefreshTokensRes, err)
	return _c
}

func (_c *Service_ListActiveRefreshTokens_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) (*v1.ListUserRefreshTokensRes, error)) *Service_ListActiveRefreshTokens_Call {
	_c.Call.Return(run)
	return _c
}

// ListUsers provides a mock function for the type Service
func (_mock *Service) ListUsers(ctx context.Context, session authn.Session, pm users.Page) (users.UsersPage, error) {
	ret := _mock.Called(ctx, session, pm)

	if len(ret) == 0 {
		panic("no return value specified for ListUsers")
	}

	var r0 users.UsersPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.Page) (users.UsersPage, error)); ok {
		return returnFunc(ctx, session, pm)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.Page) users.UsersPage); ok {
		r0 = returnFunc(ctx, session, pm)
	} else {
		r0 = ret.Get(0).(users.UsersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, users.Page) error); ok {
		r1 = returnFunc(ctx, session, pm)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_ListUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsers'
type Service_ListUsers_Call struct {
	*mock.Call
}

// ListUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - pm users.Page
func (_e *Service_Expecter) ListUsers(ctx interface{}, session interface{}, pm interface{}) *Service_ListUsers_Call {
	return &Service_ListUsers_Call{Call: _e.mock.On("ListUsers", ctx, session, pm)}
}

func (_c *Service_ListUsers_Call) Run(run func(ctx context.Context, session authn.Session, pm users.Page)) *Service_ListUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 users.Page
		if args[2] != nil {
			arg2 = args[2].(users.Page)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_ListUsers_Call) Return(usersPage users.UsersPage, err error) *Service_ListUsers_Call {
	_c.Call.Return(usersPage, err)
	return _c
}

func (_c *Service_ListUsers_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, pm users.Page) (users.UsersPage, error)) *Service_ListUsers_Call {
	_c.Call.Return(run)
	return _c
}

// OAuthAddUserPolicy provides a mock function for the type Service
func (_mock *Service) OAuthAddUserPolicy(ctx context.Context, user users.User) error {
	ret := _mock.Called(ctx, user)

	if len(ret) == 0 {
		panic("no return value specified for OAuthAddUserPolicy")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, users.User) error); ok {
		r0 = returnFunc(ctx, user)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Service_OAuthAddUserPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OAuthAddUserPolicy'
type Service_OAuthAddUserPolicy_Call struct {
	*mock.Call
}

// OAuthAddUserPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - user users.User
func (_e *Service_Expecter) OAuthAddUserPolicy(ctx interface{}, user interface{}) *Service_OAuthAddUserPolicy_Call {
	return &Service_OAuthAddUserPolicy_Call{Call: _e.mock.On("OAuthAddUserPolicy", ctx, user)}
}

func (_c *Service_OAuthAddUserPolicy_Call) Run(run func(ctx context.Context, user users.User)) *Service_OAuthAddUserPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 users.User
		if args[1] != nil {
			arg1 = args[1].(users.User)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_OAuthAddUserPolicy_Call) Return(err error) *Service_OAuthAddUserPolicy_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_OAuthAddUserPolicy_Call) RunAndReturn(run func(ctx context.Context, user users.User) error) *Service_OAuthAddUserPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// OAuthCallback provides a mock function for the type Service
func (_mock *Service) OAuthCallback(ctx context.Context, user users.User) (users.User, error) {
	ret := _mock.Called(ctx, user)

	if len(ret) == 0 {
		panic("no return value specified for OAuthCallback")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, users.User) (users.User, error)); ok {
		return returnFunc(ctx, user)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, users.User) users.User); ok {
		r0 = returnFunc(ctx, user)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, users.User) error); ok {
		r1 = returnFunc(ctx, user)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_OAuthCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OAuthCallback'
type Service_OAuthCallback_Call struct {
	*mock.Call
}

// OAuthCallback is a helper method to define mock.On call
//   - ctx context.Context
//   - user users.User
func (_e *Service_Expecter) OAuthCallback(ctx interface{}, user interface{}) *Service_OAuthCallback_Call {
	return &Service_OAuthCallback_Call{Call: _e.mock.On("OAuthCallback", ctx, user)}
}

func (_c *Service_OAuthCallback_Call) Run(run func(ctx context.Context, user users.User)) *Service_OAuthCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 users.User
		if args[1] != nil {
			arg1 = args[1].(users.User)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_OAuthCallback_Call) Return(user1 users.User, err error) *Service_OAuthCallback_Call {
	_c.Call.Return(user1, err)
	return _c
}

func (_c *Service_OAuthCallback_Call) RunAndReturn(run func(ctx context.Context, user users.User) (users.User, error)) *Service_OAuthCallback_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshToken provides a mock function for the type Service
func (_mock *Service) RefreshToken(ctx context.Context, session authn.Session, refreshToken string) (*v1.Token, error) {
	ret := _mock.Called(ctx, session, refreshToken)

	if len(ret) == 0 {
		panic("no return value specified for RefreshToken")
	}

	var r0 *v1.Token
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (*v1.Token, error)); ok {
		return returnFunc(ctx, session, refreshToken)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) *v1.Token); ok {
		r0 = returnFunc(ctx, session, refreshToken)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1.Token)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok {
		r1 = returnFunc(ctx, session, refreshToken)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_RefreshToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshToken'
type Service_RefreshToken_Call struct {
	*mock.Call
}

// RefreshToken is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - refreshToken string
func (_e *Service_Expecter) RefreshToken(ctx interface{}, session interface{}, refreshToken interface{}) *Service_RefreshToken_Call {
	return &Service_RefreshToken_Call{Call: _e.mock.On("RefreshToken", ctx, session, refreshToken)}
}

func (_c *Service_RefreshToken_Call) Run(run func(ctx context.Context, session authn.Session, refreshToken string)) *Service_RefreshToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_RefreshToken_Call) Return(token *v1.Token, err error) *Service_RefreshToken_Call {
	_c.Call.Return(token, err)
	return _c
}

func (_c *Service_RefreshToken_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, refreshToken string) (*v1.Token, error)) *Service_RefreshToken_Call {
	_c.Call.Return(run)
	return _c
}

// Register provides a mock function for the type Service
func (_mock *Service) Register(ctx context.Context, session authn.Session, user users.User, selfRegister bool) (users.User, error) {
	ret := _mock.Called(ctx, session, user, selfRegister)

	if len(ret) == 0 {
		panic("no return value specified for Register")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.User, bool) (users.User, error)); ok {
		return returnFunc(ctx, session, user, selfRegister)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.User, bool) users.User); ok {
		r0 = returnFunc(ctx, session, user, selfRegister)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, users.User, bool) error); ok {
		r1 = returnFunc(ctx, session, user, selfRegister)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_Register_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Register'
type Service_Register_Call struct {
	*mock.Call
}

// Register is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - user users.User
//   - selfRegister bool
func (_e *Service_Expecter) Register(ctx interface{}, session interface{}, user interface{}, selfRegister interface{}) *Service_Register_Call {
	return &Service_Register_Call{Call: _e.mock.On("Register", ctx, session, user, selfRegister)}
}

func (_c *Service_Register_Call) Run(run func(ctx context.Context, session authn.Session, user users.User, selfRegister bool)) *Service_Register_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 users.User
		if args[2] != nil {
			arg2 = args[2].(users.User)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_Register_Call) Return(user1 users.User, err error) *Service_Register_Call {
	_c.Call.Return(user1, err)
	return _c
}

func (_c *Service_Register_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, user users.User, selfRegister bool) (users.User, error)) *Service_Register_Call {
	_c.Call.Return(run)
	return _c
}

// ResetSecret provides a mock function for the type Service
func (_mock *Service) ResetSecret(ctx context.Context, session authn.Session, secret string) error {
	ret := _mock.Called(ctx, session, secret)

	if len(ret) == 0 {
		panic("no return value specified for ResetSecret")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) error); ok {
		r0 = returnFunc(ctx, session, secret)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Service_ResetSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetSecret'
type Service_ResetSecret_Call struct {
	*mock.Call
}

// ResetSecret is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - secret string
func (_e *Service_Expecter) ResetSecret(ctx interface{}, session interface{}, secret interface{}) *Service_ResetSecret_Call {
	return &Service_ResetSecret_Call{Call: _e.mock.On("ResetSecret", ctx, session, secret)}
}

func (_c *Service_ResetSecret_Call) Run(run func(ctx context.Context, session authn.Session, secret string)) *Service_ResetSecret_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_ResetSecret_Call) Return(err error) *Service_ResetSecret_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_ResetSecret_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, secret string) error) *Service_ResetSecret_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeRefreshToken provides a mock function for the type Service
func (_mock *Service) RevokeRefreshToken(ctx context.Context, session authn.Session, tokenID string) error {
	ret := _mock.Called(ctx, session, tokenID)

	if len(ret) == 0 {
		panic("no return value specified for RevokeRefreshToken")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) error); ok {
		r0 = returnFunc(ctx, session, tokenID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Service_RevokeRefreshToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeRefreshToken'
type Service_RevokeRefreshToken_Call struct {
	*mock.Call
}

// RevokeRefreshToken is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - tokenID string
func (_e *Service_Expecter) RevokeRefreshToken(ctx interface{}, session interface{}, tokenID interface{}) *Service_RevokeRefreshToken_Call {
	return &Service_RevokeRefreshToken_Call{Call: _e.mock.On("RevokeRefreshToken", ctx, session, tokenID)}
}

func (_c *Service_RevokeRefreshToken_Call) Run(run func(ctx context.Context, session authn.Session, tokenID string)) *Service_RevokeRefreshToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_RevokeRefreshToken_Call) Return(err error) *Service_RevokeRefreshToken_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_RevokeRefreshToken_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, tokenID string) error) *Service_RevokeRefreshToken_Call {
	_c.Call.Return(run)
	return _c
}

// SearchUsers provides a mock function for the type Service
func (_mock *Service) SearchUsers(ctx context.Context, pm users.Page) (users.UsersPage, error) {
	ret := _mock.Called(ctx, pm)

	if len(ret) == 0 {
		panic("no return value specified for SearchUsers")
	}

	var r0 users.UsersPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, users.Page) (users.UsersPage, error)); ok {
		return returnFunc(ctx, pm)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, users.Page) users.UsersPage); ok {
		r0 = returnFunc(ctx, pm)
	} else {
		r0 = ret.Get(0).(users.UsersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, users.Page) error); ok {
		r1 = returnFunc(ctx, pm)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_SearchUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchUsers'
type Service_SearchUsers_Call struct {
	*mock.Call
}

// SearchUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - pm users.Page
func (_e *Service_Expecter) SearchUsers(ctx interface{}, pm interface{}) *Service_SearchUsers_Call {
	return &Service_SearchUsers_Call{Call: _e.mock.On("SearchUsers", ctx, pm)}
}

func (_c *Service_SearchUsers_Call) Run(run func(ctx context.Context, pm users.Page)) *Service_SearchUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 users.Page
		if args[1] != nil {
			arg1 = args[1].(users.Page)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_SearchUsers_Call) Return(usersPage users.UsersPage, err error) *Service_SearchUsers_Call {
	_c.Call.Return(usersPage, err)
	return _c
}

func (_c *Service_SearchUsers_Call) RunAndReturn(run func(ctx context.Context, pm users.Page) (users.UsersPage, error)) *Service_SearchUsers_Call {
	_c.Call.Return(run)
	return _c
}

// SendPasswordReset provides a mock function for the type Service
func (_mock *Service) SendPasswordReset(ctx context.Context, email string) error {
	ret := _mock.Called(ctx, email)

	if len(ret) == 0 {
		panic("no return value specified for SendPasswordReset")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, email)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Service_SendPasswordReset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendPasswordReset'
type Service_SendPasswordReset_Call struct {
	*mock.Call
}

// SendPasswordReset is a helper method to define mock.On call
//   - ctx context.Context
//   - email string
func (_e *Service_Expecter) SendPasswordReset(ctx interface{}, email interface{}) *Service_SendPasswordReset_Call {
	return &Service_SendPasswordReset_Call{Call: _e.mock.On("SendPasswordReset", ctx, email)}
}

func (_c *Service_SendPasswordReset_Call) Run(run func(ctx context.Context, email string)) *Service_SendPasswordReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_SendPasswordReset_Call) Return(err error) *Service_SendPasswordReset_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SendPasswordReset_Call) RunAndReturn(run func(ctx context.Context, email string) error) *Service_SendPasswordReset_Call {
	_c.Call.Return(run)
	return _c
}

// SendVerification provides a mock function for the type Service
func (_mock *Service) SendVerification(ctx context.Context, session authn.Session) error {
	ret := _mock.Called(ctx, session)

	if len(ret) == 0 {
		panic("no return value specified for SendVerification")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) error); ok {
		r0 = returnFunc(ctx, session)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// Service_SendVerification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendVerification'
type Service_SendVerification_Call struct {
	*mock.Call
}

// SendVerification is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
func (_e *Service_Expecter) SendVerification(ctx interface{}, session interface{}) *Service_SendVerification_Call {
	return &Service_SendVerification_Call{Call: _e.mock.On("SendVerification", ctx, session)}
}

func (_c *Service_SendVerification_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_SendVerification_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_SendVerification_Call) Return(err error) *Service_SendVerification_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *Service_SendVerification_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) error) *Service_SendVerification_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function for the type Service
func (_mock *Service) Update(ctx context.Context, session authn.Session, id string, user users.UserReq) (users.User, error) {
	ret := _mock.Called(ctx, session, id, user)

	if len(ret) == 0 {
		panic("no return value specified for Update")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) (users.User, error)); ok {
		return returnFunc(ctx, session, id, user)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) users.User); ok {
		r0 = returnFunc(ctx, session, id, user)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, users.UserReq) error); ok {
		r1 = returnFunc(ctx, session, id, user)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
type Service_Update_Call struct {
	*mock.Call
}

// Update is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
//   - user users.UserReq
func (_e *Service_Expecter) Update(ctx interface{}, session interface{}, id interface{}, user interface{}) *Service_Update_Call {
	return &Service_Update_Call{Call: _e.mock.On("Update", ctx, session, id, user)}
}

func (_c *Service_Update_Call) Run(run func(ctx context.Context, session authn.Session, id string, user users.UserReq)) *Service_Update_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 users.UserReq
		if args[3] != nil {
			arg3 = args[3].(users.UserReq)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_Update_Call) Return(user1 users.User, err error) *Service_Update_Call {
	_c.Call.Return(user1, err)
	return _c
}

func (_c *Service_Update_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, user users.UserReq) (users.User, error)) *Service_Update_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateEmail provides a mock function for the type Service
func (_mock *Service) UpdateEmail(ctx context.Context, session authn.Session, id string, email string) (users.User, error) {
	ret := _mock.Called(ctx, session, id, email)

	if len(ret) == 0 {
		panic("no return value specified for UpdateEmail")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) (users.User, error)); ok {
		return returnFunc(ctx, session, id, email)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) users.User); ok {
		r0 = returnFunc(ctx, session, id, email)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string) error); ok {
		r1 = returnFunc(ctx, session, id, email)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_UpdateEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEmail'
type Service_UpdateEmail_Call struct {
	*mock.Call
}

// UpdateEmail is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
//   - email string
func (_e *Service_Expecter) UpdateEmail(ctx interface{}, session interface{}, id interface{}, email interface{}) *Service_UpdateEmail_Call {
	return &Service_UpdateEmail_Call{Call: _e.mock.On("UpdateEmail", ctx, session, id, email)}
}

func (_c *Service_UpdateEmail_Call) Run(run func(ctx context.Context, session authn.Session, id string, email string)) *Service_UpdateEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_UpdateEmail_Call) Return(user users.User, err error) *Service_UpdateEmail_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_UpdateEmail_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, email string) (users.User, error)) *Service_UpdateEmail_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateProfilePicture provides a mock function for the type Service
func (_mock *Service) UpdateProfilePicture(ctx context.Context, session authn.Session, id string, usr users.UserReq) (users.User, error) {
	ret := _mock.Called(ctx, session, id, usr)

	if len(ret) == 0 {
		panic("no return value specified for UpdateProfilePicture")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) (users.User, error)); ok {
		return returnFunc(ctx, session, id, usr)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) users.User); ok {
		r0 = returnFunc(ctx, session, id, usr)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, users.UserReq) error); ok {
		r1 = returnFunc(ctx, session, id, usr)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_UpdateProfilePicture_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProfilePicture'
type Service_UpdateProfilePicture_Call struct {
	*mock.Call
}

// UpdateProfilePicture is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
//   - usr users.UserReq
func (_e *Service_Expecter) UpdateProfilePicture(ctx interface{}, session interface{}, id interface{}, usr interface{}) *Service_UpdateProfilePicture_Call {
	return &Service_UpdateProfilePicture_Call{Call: _e.mock.On("UpdateProfilePicture", ctx, session, id, usr)}
}

func (_c *Service_UpdateProfilePicture_Call) Run(run func(ctx context.Context, session authn.Session, id string, usr users.UserReq)) *Service_UpdateProfilePicture_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 users.UserReq
		if args[3] != nil {
			arg3 = args[3].(users.UserReq)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_UpdateProfilePicture_Call) Return(user users.User, err error) *Service_UpdateProfilePicture_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_UpdateProfilePicture_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, usr users.UserReq) (users.User, error)) *Service_UpdateProfilePicture_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRole provides a mock function for the type Service
func (_mock *Service) UpdateRole(ctx context.Context, session authn.Session, user users.User) (users.User, error) {
	ret := _mock.Called(ctx, session, user)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRole")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.User) (users.User, error)); ok {
		return returnFunc(ctx, session, user)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.User) users.User); ok {
		r0 = returnFunc(ctx, session, user)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, users.User) error); ok {
		r1 = returnFunc(ctx, session, user)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_UpdateRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRole'
type Service_UpdateRole_Call struct {
	*mock.Call
}

// UpdateRole is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - user users.User
func (_e *Service_Expecter) UpdateRole(ctx interface{}, session interface{}, user interface{}) *Service_UpdateRole_Call {
	return &Service_UpdateRole_Call{Call: _e.mock.On("UpdateRole", ctx, session, user)}
}

func (_c *Service_UpdateRole_Call) Run(run func(ctx context.Context, session authn.Session, user users.User)) *Service_UpdateRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 users.User
		if args[2] != nil {
			arg2 = args[2].(users.User)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_UpdateRole_Call) Return(user1 users.User, err error) *Service_UpdateRole_Call {
	_c.Call.Return(user1, err)
	return _c
}

func (_c *Service_UpdateRole_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, user users.User) (users.User, error)) *Service_UpdateRole_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSecret provides a mock function for the type Service
func (_mock *Service) UpdateSecret(ctx context.Context, session authn.Session, oldSecret string, newSecret string) (users.User, error) {
	ret := _mock.Called(ctx, session, oldSecret, newSecret)

	if len(ret) == 0 {
		panic("no return value specified for UpdateSecret")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) (users.User, error)); ok {
		return returnFunc(ctx, session, oldSecret, newSecret)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) users.User); ok {
		r0 = returnFunc(ctx, session, oldSecret, newSecret)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string) error); ok {
		r1 = returnFunc(ctx, session, oldSecret, newSecret)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_UpdateSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSecret'
type Service_UpdateSecret_Call struct {
	*mock.Call
}

// UpdateSecret is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - oldSecret string
//   - newSecret string
func (_e *Service_Expecter) UpdateSecret(ctx interface{}, session interface{}, oldSecret interface{}, newSecret interface{}) *Service_UpdateSecret_Call {
	return &Service_UpdateSecret_Call{Call: _e.mock.On("UpdateSecret", ctx, session, oldSecret, newSecret)}
}

func (_c *Service_UpdateSecret_Call) Run(run func(ctx context.Context, session authn.Session, oldSecret string, newSecret string)) *Service_UpdateSecret_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_UpdateSecret_Call) Return(user users.User, err error) *Service_UpdateSecret_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_UpdateSecret_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, oldSecret string, newSecret string) (users.User, error)) *Service_UpdateSecret_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTags provides a mock function for the type Service
func (_mock *Service) UpdateTags(ctx context.Context, session authn.Session, id string, user users.UserReq) (users.User, error) {
	ret := _mock.Called(ctx, session, id, user)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTags")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) (users.User, error)); ok {
		return returnFunc(ctx, session, id, user)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) users.User); ok {
		r0 = returnFunc(ctx, session, id, user)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, users.UserReq) error); ok {
		r1 = returnFunc(ctx, session, id, user)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_UpdateTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTags'
type Service_UpdateTags_Call struct {
	*mock.Call
}

// UpdateTags is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
//   - user users.UserReq
func (_e *Service_Expecter) UpdateTags(ctx interface{}, session interface{}, id interface{}, user interface{}) *Service_UpdateTags_Call {
	return &Service_UpdateTags_Call{Call: _e.mock.On("UpdateTags", ctx, session, id, user)}
}

func (_c *Service_UpdateTags_Call) Run(run func(ctx context.Context, session authn.Session, id string, user users.UserReq)) *Service_UpdateTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 users.UserReq
		if args[3] != nil {
			arg3 = args[3].(users.UserReq)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_UpdateTags_Call) Return(user1 users.User, err error) *Service_UpdateTags_Call {
	_c.Call.Return(user1, err)
	return _c
}

func (_c *Service_UpdateTags_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, user users.UserReq) (users.User, error)) *Service_UpdateTags_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUsername provides a mock function for the type Service
func (_mock *Service) UpdateUsername(ctx context.Context, session authn.Session, id string, username string) (users.User, error) {
	ret := _mock.Called(ctx, session, id, username)

	if len(ret) == 0 {
		panic("no return value specified for UpdateUsername")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) (users.User, error)); ok {
		return returnFunc(ctx, session, id, username)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) users.User); ok {
		r0 = returnFunc(ctx, session, id, username)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string) error); ok {
		r1 = returnFunc(ctx, session, id, username)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_UpdateUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUsername'
type Service_UpdateUsername_Call struct {
	*mock.Call
}

// UpdateUsername is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
//   - username string
func (_e *Service_Expecter) UpdateUsername(ctx interface{}, session interface{}, id interface{}, username interface{}) *Service_UpdateUsername_Call {
	return &Service_UpdateUsername_Call{Call: _e.mock.On("UpdateUsername", ctx, session, id, username)}
}

func (_c *Service_UpdateUsername_Call) Run(run func(ctx context.Context, session authn.Session, id string, username string)) *Service_UpdateUsername_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *Service_UpdateUsername_Call) Return(user users.User, err error) *Service_UpdateUsername_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_UpdateUsername_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, username string) (users.User, error)) *Service_UpdateUsername_Call {
	_c.Call.Return(run)
	return _c
}

// VerifyEmail provides a mock function for the type Service
func (_mock *Service) VerifyEmail(ctx context.Context, verificationToken string) (users.User, error) {
	ret := _mock.Called(ctx, verificationToken)

	if len(ret) == 0 {
		panic("no return value specified for VerifyEmail")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (users.User, error)); ok {
		return returnFunc(ctx, verificationToken)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) users.User); ok {
		r0 = returnFunc(ctx, verificationToken)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, verificationToken)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_VerifyEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyEmail'
type Service_VerifyEmail_Call struct {
	*mock.Call
}

// VerifyEmail is a helper method to define mock.On call
//   - ctx context.Context
//   - verificationToken string
func (_e *Service_Expecter) VerifyEmail(ctx interface{}, verificationToken interface{}) *Service_VerifyEmail_Call {
	return &Service_VerifyEmail_Call{Call: _e.mock.On("VerifyEmail", ctx, verificationToken)}
}

func (_c *Service_VerifyEmail_Call) Run(run func(ctx context.Context, verificationToken string)) *Service_VerifyEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_VerifyEmail_Call) Return(user users.User, err error) *Service_VerifyEmail_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_VerifyEmail_Call) RunAndReturn(run func(ctx context.Context, verificationToken string) (users.User, error)) *Service_VerifyEmail_Call {
	_c.Call.Return(run)
	return _c
}

// View provides a mock function for the type Service
func (_mock *Service) View(ctx context.Context, session authn.Session, id string) (users.User, error) {
	ret := _mock.Called(ctx, session, id)

	if len(ret) == 0 {
		panic("no return value specified for View")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (users.User, error)); ok {
		return returnFunc(ctx, session, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) users.User); ok {
		r0 = returnFunc(ctx, session, id)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok {
		r1 = returnFunc(ctx, session, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_View_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'View'
type Service_View_Call struct {
	*mock.Call
}

// View is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
//   - id string
func (_e *Service_Expecter) View(ctx interface{}, session interface{}, id interface{}) *Service_View_Call {
	return &Service_View_Call{Call: _e.mock.On("View", ctx, session, id)}
}

func (_c *Service_View_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_View_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *Service_View_Call) Return(user users.User, err error) *Service_View_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_View_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) (users.User, error)) *Service_View_Call {
	_c.Call.Return(run)
	return _c
}

// ViewProfile provides a mock function for the type Service
func (_mock *Service) ViewProfile(ctx context.Context, session authn.Session) (users.User, error) {
	ret := _mock.Called(ctx, session)

	if len(ret) == 0 {
		panic("no return value specified for ViewProfile")
	}

	var r0 users.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) (users.User, error)); ok {
		return returnFunc(ctx, session)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) users.User); ok {
		r0 = returnFunc(ctx, session)
	} else {
		r0 = ret.Get(0).(users.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session) error); ok {
		r1 = returnFunc(ctx, session)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// Service_ViewProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewProfile'
type Service_ViewProfile_Call struct {
	*mock.Call
}

// ViewProfile is a helper method to define mock.On call
//   - ctx context.Context
//   - session authn.Session
func (_e *Service_Expecter) ViewProfile(ctx interface{}, session interface{}) *Service_ViewProfile_Call {
	return &Service_ViewProfile_Call{Call: _e.mock.On("ViewProfile", ctx, session)}
}

func (_c *Service_ViewProfile_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_ViewProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 authn.Session
		if args[1] != nil {
			arg1 = args[1].(authn.Session)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *Service_ViewProfile_Call) Return(user users.User, err error) *Service_ViewProfile_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *Service_ViewProfile_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) (users.User, error)) *Service_ViewProfile_Call {
	_c.Call.Return(run)
	return _c
}
