// Code generated by mockery v2.48.0. DO NOT EDIT.

package database

import (
	context "context"

	mock "github.com/stretchr/testify/mock"
	database "opencsg.com/csghub-server/builder/store/database"
)

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

type MockUserStore_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUserStore) EXPECT() *MockUserStore_Expecter {
	return &MockUserStore_Expecter{mock: &_m.Mock}
}

// ChangeUserName provides a mock function with given fields: ctx, username, newUsername
func (_m *MockUserStore) ChangeUserName(ctx context.Context, username string, newUsername string) error {
	ret := _m.Called(ctx, username, newUsername)

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

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

	return r0
}

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

// ChangeUserName is a helper method to define mock.On call
//   - ctx context.Context
//   - username string
//   - newUsername string
func (_e *MockUserStore_Expecter) ChangeUserName(ctx interface{}, username interface{}, newUsername interface{}) *MockUserStore_ChangeUserName_Call {
	return &MockUserStore_ChangeUserName_Call{Call: _e.mock.On("ChangeUserName", ctx, username, newUsername)}
}

func (_c *MockUserStore_ChangeUserName_Call) Run(run func(ctx context.Context, username string, newUsername string)) *MockUserStore_ChangeUserName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

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

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

// CountUsers provides a mock function with given fields: ctx
func (_m *MockUserStore) CountUsers(ctx context.Context) (int, error) {
	ret := _m.Called(ctx)

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

	var r0 int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (int, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) int); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(int)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CountUsers is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserStore_Expecter) CountUsers(ctx interface{}) *MockUserStore_CountUsers_Call {
	return &MockUserStore_CountUsers_Call{Call: _e.mock.On("CountUsers", ctx)}
}

func (_c *MockUserStore_CountUsers_Call) Run(run func(ctx context.Context)) *MockUserStore_CountUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockUserStore_CountUsers_Call) Return(_a0 int, _a1 error) *MockUserStore_CountUsers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockUserStore_CountUsers_Call) RunAndReturn(run func(context.Context) (int, error)) *MockUserStore_CountUsers_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function with given fields: ctx, user, namespace
func (_m *MockUserStore) Create(ctx context.Context, user *database.User, namespace *database.Namespace) error {
	ret := _m.Called(ctx, user, namespace)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *database.User, *database.Namespace) error); ok {
		r0 = rf(ctx, user, namespace)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - user *database.User
//   - namespace *database.Namespace
func (_e *MockUserStore_Expecter) Create(ctx interface{}, user interface{}, namespace interface{}) *MockUserStore_Create_Call {
	return &MockUserStore_Create_Call{Call: _e.mock.On("Create", ctx, user, namespace)}
}

func (_c *MockUserStore_Create_Call) Run(run func(ctx context.Context, user *database.User, namespace *database.Namespace)) *MockUserStore_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*database.User), args[2].(*database.Namespace))
	})
	return _c
}

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

func (_c *MockUserStore_Create_Call) RunAndReturn(run func(context.Context, *database.User, *database.Namespace) error) *MockUserStore_Create_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteUserAndRelations provides a mock function with given fields: ctx, input
func (_m *MockUserStore) DeleteUserAndRelations(ctx context.Context, input database.User) error {
	ret := _m.Called(ctx, input)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, database.User) error); ok {
		r0 = rf(ctx, input)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteUserAndRelations is a helper method to define mock.On call
//   - ctx context.Context
//   - input database.User
func (_e *MockUserStore_Expecter) DeleteUserAndRelations(ctx interface{}, input interface{}) *MockUserStore_DeleteUserAndRelations_Call {
	return &MockUserStore_DeleteUserAndRelations_Call{Call: _e.mock.On("DeleteUserAndRelations", ctx, input)}
}

func (_c *MockUserStore_DeleteUserAndRelations_Call) Run(run func(ctx context.Context, input database.User)) *MockUserStore_DeleteUserAndRelations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(database.User))
	})
	return _c
}

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

func (_c *MockUserStore_DeleteUserAndRelations_Call) RunAndReturn(run func(context.Context, database.User) error) *MockUserStore_DeleteUserAndRelations_Call {
	_c.Call.Return(run)
	return _c
}

// FindByAccessToken provides a mock function with given fields: ctx, token
func (_m *MockUserStore) FindByAccessToken(ctx context.Context, token string) (*database.User, error) {
	ret := _m.Called(ctx, token)

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

	var r0 *database.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*database.User, error)); ok {
		return rf(ctx, token)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *database.User); ok {
		r0 = rf(ctx, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, token)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindByAccessToken is a helper method to define mock.On call
//   - ctx context.Context
//   - token string
func (_e *MockUserStore_Expecter) FindByAccessToken(ctx interface{}, token interface{}) *MockUserStore_FindByAccessToken_Call {
	return &MockUserStore_FindByAccessToken_Call{Call: _e.mock.On("FindByAccessToken", ctx, token)}
}

func (_c *MockUserStore_FindByAccessToken_Call) Run(run func(ctx context.Context, token string)) *MockUserStore_FindByAccessToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockUserStore_FindByAccessToken_Call) Return(_a0 *database.User, _a1 error) *MockUserStore_FindByAccessToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockUserStore_FindByAccessToken_Call) RunAndReturn(run func(context.Context, string) (*database.User, error)) *MockUserStore_FindByAccessToken_Call {
	_c.Call.Return(run)
	return _c
}

// FindByGitAccessToken provides a mock function with given fields: ctx, token
func (_m *MockUserStore) FindByGitAccessToken(ctx context.Context, token string) (*database.User, error) {
	ret := _m.Called(ctx, token)

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

	var r0 *database.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*database.User, error)); ok {
		return rf(ctx, token)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *database.User); ok {
		r0 = rf(ctx, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, token)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindByGitAccessToken is a helper method to define mock.On call
//   - ctx context.Context
//   - token string
func (_e *MockUserStore_Expecter) FindByGitAccessToken(ctx interface{}, token interface{}) *MockUserStore_FindByGitAccessToken_Call {
	return &MockUserStore_FindByGitAccessToken_Call{Call: _e.mock.On("FindByGitAccessToken", ctx, token)}
}

func (_c *MockUserStore_FindByGitAccessToken_Call) Run(run func(ctx context.Context, token string)) *MockUserStore_FindByGitAccessToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockUserStore_FindByGitAccessToken_Call) Return(_a0 *database.User, _a1 error) *MockUserStore_FindByGitAccessToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockUserStore_FindByGitAccessToken_Call) RunAndReturn(run func(context.Context, string) (*database.User, error)) *MockUserStore_FindByGitAccessToken_Call {
	_c.Call.Return(run)
	return _c
}

// FindByID provides a mock function with given fields: ctx, id
func (_m *MockUserStore) FindByID(ctx context.Context, id int) (database.User, error) {
	ret := _m.Called(ctx, id)

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

	var r0 database.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int) (database.User, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int) database.User); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Get(0).(database.User)
	}

	if rf, ok := ret.Get(1).(func(context.Context, int) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindByID is a helper method to define mock.On call
//   - ctx context.Context
//   - id int
func (_e *MockUserStore_Expecter) FindByID(ctx interface{}, id interface{}) *MockUserStore_FindByID_Call {
	return &MockUserStore_FindByID_Call{Call: _e.mock.On("FindByID", ctx, id)}
}

func (_c *MockUserStore_FindByID_Call) Run(run func(ctx context.Context, id int)) *MockUserStore_FindByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int))
	})
	return _c
}

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

func (_c *MockUserStore_FindByID_Call) RunAndReturn(run func(context.Context, int) (database.User, error)) *MockUserStore_FindByID_Call {
	_c.Call.Return(run)
	return _c
}

// FindByUUID provides a mock function with given fields: ctx, uuid
func (_m *MockUserStore) FindByUUID(ctx context.Context, uuid string) (*database.User, error) {
	ret := _m.Called(ctx, uuid)

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

	var r0 *database.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*database.User, error)); ok {
		return rf(ctx, uuid)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *database.User); ok {
		r0 = rf(ctx, uuid)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, uuid)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindByUUID is a helper method to define mock.On call
//   - ctx context.Context
//   - uuid string
func (_e *MockUserStore_Expecter) FindByUUID(ctx interface{}, uuid interface{}) *MockUserStore_FindByUUID_Call {
	return &MockUserStore_FindByUUID_Call{Call: _e.mock.On("FindByUUID", ctx, uuid)}
}

func (_c *MockUserStore_FindByUUID_Call) Run(run func(ctx context.Context, uuid string)) *MockUserStore_FindByUUID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockUserStore_FindByUUID_Call) Return(_a0 *database.User, _a1 error) *MockUserStore_FindByUUID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockUserStore_FindByUUID_Call) RunAndReturn(run func(context.Context, string) (*database.User, error)) *MockUserStore_FindByUUID_Call {
	_c.Call.Return(run)
	return _c
}

// FindByUsername provides a mock function with given fields: ctx, username
func (_m *MockUserStore) FindByUsername(ctx context.Context, username string) (database.User, error) {
	ret := _m.Called(ctx, username)

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

	var r0 database.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (database.User, error)); ok {
		return rf(ctx, username)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) database.User); ok {
		r0 = rf(ctx, username)
	} else {
		r0 = ret.Get(0).(database.User)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, username)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindByUsername is a helper method to define mock.On call
//   - ctx context.Context
//   - username string
func (_e *MockUserStore_Expecter) FindByUsername(ctx interface{}, username interface{}) *MockUserStore_FindByUsername_Call {
	return &MockUserStore_FindByUsername_Call{Call: _e.mock.On("FindByUsername", ctx, username)}
}

func (_c *MockUserStore_FindByUsername_Call) Run(run func(ctx context.Context, username string)) *MockUserStore_FindByUsername_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

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

func (_c *MockUserStore_FindByUsername_Call) RunAndReturn(run func(context.Context, string) (database.User, error)) *MockUserStore_FindByUsername_Call {
	_c.Call.Return(run)
	return _c
}

// Index provides a mock function with given fields: ctx
func (_m *MockUserStore) Index(ctx context.Context) ([]database.User, error) {
	ret := _m.Called(ctx)

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

	var r0 []database.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]database.User, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []database.User); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]database.User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Index is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserStore_Expecter) Index(ctx interface{}) *MockUserStore_Index_Call {
	return &MockUserStore_Index_Call{Call: _e.mock.On("Index", ctx)}
}

func (_c *MockUserStore_Index_Call) Run(run func(ctx context.Context)) *MockUserStore_Index_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockUserStore_Index_Call) Return(users []database.User, err error) *MockUserStore_Index_Call {
	_c.Call.Return(users, err)
	return _c
}

func (_c *MockUserStore_Index_Call) RunAndReturn(run func(context.Context) ([]database.User, error)) *MockUserStore_Index_Call {
	_c.Call.Return(run)
	return _c
}

// IndexWithSearch provides a mock function with given fields: ctx, search, per, page
func (_m *MockUserStore) IndexWithSearch(ctx context.Context, search string, per int, page int) ([]database.User, int, error) {
	ret := _m.Called(ctx, search, per, page)

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

	var r0 []database.User
	var r1 int
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string, int, int) ([]database.User, int, error)); ok {
		return rf(ctx, search, per, page)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, int, int) []database.User); ok {
		r0 = rf(ctx, search, per, page)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]database.User)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, int, int) int); ok {
		r1 = rf(ctx, search, per, page)
	} else {
		r1 = ret.Get(1).(int)
	}

	if rf, ok := ret.Get(2).(func(context.Context, string, int, int) error); ok {
		r2 = rf(ctx, search, per, page)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// IndexWithSearch is a helper method to define mock.On call
//   - ctx context.Context
//   - search string
//   - per int
//   - page int
func (_e *MockUserStore_Expecter) IndexWithSearch(ctx interface{}, search interface{}, per interface{}, page interface{}) *MockUserStore_IndexWithSearch_Call {
	return &MockUserStore_IndexWithSearch_Call{Call: _e.mock.On("IndexWithSearch", ctx, search, per, page)}
}

func (_c *MockUserStore_IndexWithSearch_Call) Run(run func(ctx context.Context, search string, per int, page int)) *MockUserStore_IndexWithSearch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(int))
	})
	return _c
}

func (_c *MockUserStore_IndexWithSearch_Call) Return(users []database.User, count int, err error) *MockUserStore_IndexWithSearch_Call {
	_c.Call.Return(users, count, err)
	return _c
}

func (_c *MockUserStore_IndexWithSearch_Call) RunAndReturn(run func(context.Context, string, int, int) ([]database.User, int, error)) *MockUserStore_IndexWithSearch_Call {
	_c.Call.Return(run)
	return _c
}

// IsExist provides a mock function with given fields: ctx, username
func (_m *MockUserStore) IsExist(ctx context.Context, username string) (bool, error) {
	ret := _m.Called(ctx, username)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
		return rf(ctx, username)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) bool); ok {
		r0 = rf(ctx, username)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, username)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// IsExist is a helper method to define mock.On call
//   - ctx context.Context
//   - username string
func (_e *MockUserStore_Expecter) IsExist(ctx interface{}, username interface{}) *MockUserStore_IsExist_Call {
	return &MockUserStore_IsExist_Call{Call: _e.mock.On("IsExist", ctx, username)}
}

func (_c *MockUserStore_IsExist_Call) Run(run func(ctx context.Context, username string)) *MockUserStore_IsExist_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockUserStore_IsExist_Call) Return(exists bool, err error) *MockUserStore_IsExist_Call {
	_c.Call.Return(exists, err)
	return _c
}

func (_c *MockUserStore_IsExist_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *MockUserStore_IsExist_Call {
	_c.Call.Return(run)
	return _c
}

// IsExistByUUID provides a mock function with given fields: ctx, uuid
func (_m *MockUserStore) IsExistByUUID(ctx context.Context, uuid string) (bool, error) {
	ret := _m.Called(ctx, uuid)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
		return rf(ctx, uuid)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) bool); ok {
		r0 = rf(ctx, uuid)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, uuid)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// IsExistByUUID is a helper method to define mock.On call
//   - ctx context.Context
//   - uuid string
func (_e *MockUserStore_Expecter) IsExistByUUID(ctx interface{}, uuid interface{}) *MockUserStore_IsExistByUUID_Call {
	return &MockUserStore_IsExistByUUID_Call{Call: _e.mock.On("IsExistByUUID", ctx, uuid)}
}

func (_c *MockUserStore_IsExistByUUID_Call) Run(run func(ctx context.Context, uuid string)) *MockUserStore_IsExistByUUID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockUserStore_IsExistByUUID_Call) Return(exists bool, err error) *MockUserStore_IsExistByUUID_Call {
	_c.Call.Return(exists, err)
	return _c
}

func (_c *MockUserStore_IsExistByUUID_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *MockUserStore_IsExistByUUID_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function with given fields: ctx, user
func (_m *MockUserStore) Update(ctx context.Context, user *database.User) error {
	ret := _m.Called(ctx, user)

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

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

	return r0
}

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

// Update is a helper method to define mock.On call
//   - ctx context.Context
//   - user *database.User
func (_e *MockUserStore_Expecter) Update(ctx interface{}, user interface{}) *MockUserStore_Update_Call {
	return &MockUserStore_Update_Call{Call: _e.mock.On("Update", ctx, user)}
}

func (_c *MockUserStore_Update_Call) Run(run func(ctx context.Context, user *database.User)) *MockUserStore_Update_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*database.User))
	})
	return _c
}

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

func (_c *MockUserStore_Update_Call) RunAndReturn(run func(context.Context, *database.User) error) *MockUserStore_Update_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockUserStore creates a new instance of MockUserStore. 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 NewMockUserStore(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUserStore {
	mock := &MockUserStore{}
	mock.Mock.Test(t)

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

	return mock
}
