perms-system-server/internal/testutil/mocks/mock_user_model.go

// Code generated by MockGen. DO NOT EDIT.
// Source: internal/model/user/sysUserModel.go
//
// Generated by this command:
//
//	mockgen -source=internal/model/user/sysUserModel.go -destination=internal/testutil/mocks/mock_user_model.go -package=mocks
//

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

import (
	context "context"
	sql "database/sql"
	user "perms-system-server/internal/model/user"
	reflect "reflect"

	sqlx "github.com/zeromicro/go-zero/core/stores/sqlx"
	gomock "go.uber.org/mock/gomock"
)

// MockSysUserModel is a mock of SysUserModel interface.
type MockSysUserModel struct {
	ctrl     *gomock.Controller
	recorder *MockSysUserModelMockRecorder
	isgomock struct{}
}

// MockSysUserModelMockRecorder is the mock recorder for MockSysUserModel.
type MockSysUserModelMockRecorder struct {
	mock *MockSysUserModel
}

// NewMockSysUserModel creates a new mock instance.
func NewMockSysUserModel(ctrl *gomock.Controller) *MockSysUserModel {
	mock := &MockSysUserModel{ctrl: ctrl}
	mock.recorder = &MockSysUserModelMockRecorder{mock}
	return mock
}

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

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

// BatchDelete indicates an expected call of BatchDelete.
func (mr *MockSysUserModelMockRecorder) BatchDelete(ctx, ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDelete", reflect.TypeOf((*MockSysUserModel)(nil).BatchDelete), ctx, ids)
}

// BatchDeleteWithTx mocks base method.
func (m *MockSysUserModel) BatchDeleteWithTx(ctx context.Context, session sqlx.Session, ids []int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchDeleteWithTx", ctx, session, ids)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchDeleteWithTx indicates an expected call of BatchDeleteWithTx.
func (mr *MockSysUserModelMockRecorder) BatchDeleteWithTx(ctx, session, ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteWithTx", reflect.TypeOf((*MockSysUserModel)(nil).BatchDeleteWithTx), ctx, session, ids)
}

// BatchIncrementTokenVersionWithTx mocks base method.
func (m *MockSysUserModel) BatchIncrementTokenVersionWithTx(ctx context.Context, session sqlx.Session, ids []int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchIncrementTokenVersionWithTx", ctx, session, ids)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchIncrementTokenVersionWithTx indicates an expected call of BatchIncrementTokenVersionWithTx.
func (mr *MockSysUserModelMockRecorder) BatchIncrementTokenVersionWithTx(ctx, session, ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchIncrementTokenVersionWithTx", reflect.TypeOf((*MockSysUserModel)(nil).BatchIncrementTokenVersionWithTx), ctx, session, ids)
}

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

// BatchInsert indicates an expected call of BatchInsert.
func (mr *MockSysUserModelMockRecorder) BatchInsert(ctx, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchInsert", reflect.TypeOf((*MockSysUserModel)(nil).BatchInsert), ctx, dataList)
}

// BatchInsertWithTx mocks base method.
func (m *MockSysUserModel) BatchInsertWithTx(ctx context.Context, session sqlx.Session, dataList []*user.SysUser) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchInsertWithTx", ctx, session, dataList)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchInsertWithTx indicates an expected call of BatchInsertWithTx.
func (mr *MockSysUserModelMockRecorder) BatchInsertWithTx(ctx, session, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchInsertWithTx", reflect.TypeOf((*MockSysUserModel)(nil).BatchInsertWithTx), ctx, session, dataList)
}

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

// BatchUpdate indicates an expected call of BatchUpdate.
func (mr *MockSysUserModelMockRecorder) BatchUpdate(ctx, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdate", reflect.TypeOf((*MockSysUserModel)(nil).BatchUpdate), ctx, dataList)
}

// BatchUpdateWithTx mocks base method.
func (m *MockSysUserModel) BatchUpdateWithTx(ctx context.Context, session sqlx.Session, dataList []*user.SysUser) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchUpdateWithTx", ctx, session, dataList)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchUpdateWithTx indicates an expected call of BatchUpdateWithTx.
func (mr *MockSysUserModelMockRecorder) BatchUpdateWithTx(ctx, session, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdateWithTx", reflect.TypeOf((*MockSysUserModel)(nil).BatchUpdateWithTx), ctx, session, dataList)
}

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

// Delete indicates an expected call of Delete.
func (mr *MockSysUserModelMockRecorder) Delete(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSysUserModel)(nil).Delete), ctx, id)
}

// DeleteWithTx mocks base method.
func (m *MockSysUserModel) DeleteWithTx(ctx context.Context, session sqlx.Session, id int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWithTx", ctx, session, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWithTx indicates an expected call of DeleteWithTx.
func (mr *MockSysUserModelMockRecorder) DeleteWithTx(ctx, session, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWithTx", reflect.TypeOf((*MockSysUserModel)(nil).DeleteWithTx), ctx, session, id)
}

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

// FindByIds indicates an expected call of FindByIds.
func (mr *MockSysUserModelMockRecorder) FindByIds(ctx, ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByIds", reflect.TypeOf((*MockSysUserModel)(nil).FindByIds), ctx, ids)
}

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

// FindIdsByDeptId indicates an expected call of FindIdsByDeptId.
func (mr *MockSysUserModelMockRecorder) FindIdsByDeptId(ctx, deptId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindIdsByDeptId", reflect.TypeOf((*MockSysUserModel)(nil).FindIdsByDeptId), ctx, deptId)
}

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

// FindIdsByDeptIdForShareTx indicates an expected call of FindIdsByDeptIdForShareTx.
func (mr *MockSysUserModelMockRecorder) FindIdsByDeptIdForShareTx(ctx, session, deptId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindIdsByDeptIdForShareTx", reflect.TypeOf((*MockSysUserModel)(nil).FindIdsByDeptIdForShareTx), ctx, session, deptId)
}

// FindListByFilter mocks base method.
func (m *MockSysUserModel) FindListByFilter(ctx context.Context, filter user.UserListFilter, page, pageSize int64) ([]*user.SysUser, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindListByFilter", ctx, filter, page, pageSize)
	ret0, _ := ret[0].([]*user.SysUser)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FindListByFilter indicates an expected call of FindListByFilter.
func (mr *MockSysUserModelMockRecorder) FindListByFilter(ctx, filter, page, pageSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindListByFilter", reflect.TypeOf((*MockSysUserModel)(nil).FindListByFilter), ctx, filter, page, pageSize)
}

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

// FindListByPage indicates an expected call of FindListByPage.
func (mr *MockSysUserModelMockRecorder) FindListByPage(ctx, page, pageSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindListByPage", reflect.TypeOf((*MockSysUserModel)(nil).FindListByPage), ctx, page, pageSize)
}

// FindListByProductMembers mocks base method.
func (m *MockSysUserModel) FindListByProductMembers(ctx context.Context, productCode string, page, pageSize int64) ([]*user.SysUser, map[int64]string, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindListByProductMembers", ctx, productCode, page, pageSize)
	ret0, _ := ret[0].([]*user.SysUser)
	ret1, _ := ret[1].(map[int64]string)
	ret2, _ := ret[2].(int64)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// FindListByProductMembers indicates an expected call of FindListByProductMembers.
func (mr *MockSysUserModelMockRecorder) FindListByProductMembers(ctx, productCode, page, pageSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindListByProductMembers", reflect.TypeOf((*MockSysUserModel)(nil).FindListByProductMembers), ctx, productCode, page, pageSize)
}

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

// FindOne indicates an expected call of FindOne.
func (mr *MockSysUserModelMockRecorder) FindOne(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockSysUserModel)(nil).FindOne), ctx, id)
}

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

// FindOneByUsername indicates an expected call of FindOneByUsername.
func (mr *MockSysUserModelMockRecorder) FindOneByUsername(ctx, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneByUsername", reflect.TypeOf((*MockSysUserModel)(nil).FindOneByUsername), ctx, username)
}

// FindOneByUsernameWithTx mocks base method.
func (m *MockSysUserModel) FindOneByUsernameWithTx(ctx context.Context, session sqlx.Session, username string) (*user.SysUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneByUsernameWithTx", ctx, session, username)
	ret0, _ := ret[0].(*user.SysUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOneByUsernameWithTx indicates an expected call of FindOneByUsernameWithTx.
func (mr *MockSysUserModelMockRecorder) FindOneByUsernameWithTx(ctx, session, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneByUsernameWithTx", reflect.TypeOf((*MockSysUserModel)(nil).FindOneByUsernameWithTx), ctx, session, username)
}

// FindOneWithTx mocks base method.
func (m *MockSysUserModel) FindOneWithTx(ctx context.Context, session sqlx.Session, id int64) (*user.SysUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneWithTx", ctx, session, id)
	ret0, _ := ret[0].(*user.SysUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOneWithTx indicates an expected call of FindOneWithTx.
func (mr *MockSysUserModelMockRecorder) FindOneWithTx(ctx, session, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneWithTx", reflect.TypeOf((*MockSysUserModel)(nil).FindOneWithTx), ctx, session, id)
}

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

// IncrementTokenVersion indicates an expected call of IncrementTokenVersion.
func (mr *MockSysUserModelMockRecorder) IncrementTokenVersion(ctx, id, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementTokenVersion", reflect.TypeOf((*MockSysUserModel)(nil).IncrementTokenVersion), ctx, id, username)
}

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

// IncrementTokenVersionIfMatch indicates an expected call of IncrementTokenVersionIfMatch.
func (mr *MockSysUserModelMockRecorder) IncrementTokenVersionIfMatch(ctx, id, username, expected any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementTokenVersionIfMatch", reflect.TypeOf((*MockSysUserModel)(nil).IncrementTokenVersionIfMatch), ctx, id, username, expected)
}

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

// IncrementTokenVersionWithTx indicates an expected call of IncrementTokenVersionWithTx.
func (mr *MockSysUserModelMockRecorder) IncrementTokenVersionWithTx(ctx, session, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementTokenVersionWithTx", reflect.TypeOf((*MockSysUserModel)(nil).IncrementTokenVersionWithTx), ctx, session, id)
}

// Insert mocks base method.
func (m *MockSysUserModel) Insert(ctx context.Context, data *user.SysUser) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", ctx, data)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Insert indicates an expected call of Insert.
func (mr *MockSysUserModelMockRecorder) Insert(ctx, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockSysUserModel)(nil).Insert), ctx, data)
}

// InsertWithTx mocks base method.
func (m *MockSysUserModel) InsertWithTx(ctx context.Context, session sqlx.Session, data *user.SysUser) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWithTx", ctx, session, data)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWithTx indicates an expected call of InsertWithTx.
func (mr *MockSysUserModelMockRecorder) InsertWithTx(ctx, session, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWithTx", reflect.TypeOf((*MockSysUserModel)(nil).InsertWithTx), ctx, session, data)
}

// InvalidateProfileCache mocks base method.
func (m *MockSysUserModel) InvalidateProfileCache(ctx context.Context, id int64, username string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InvalidateProfileCache", ctx, id, username)
}

// InvalidateProfileCache indicates an expected call of InvalidateProfileCache.
func (mr *MockSysUserModelMockRecorder) InvalidateProfileCache(ctx, id, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateProfileCache", reflect.TypeOf((*MockSysUserModel)(nil).InvalidateProfileCache), ctx, id, username)
}

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

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

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

// TransactCtx indicates an expected call of TransactCtx.
func (mr *MockSysUserModelMockRecorder) TransactCtx(ctx, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactCtx", reflect.TypeOf((*MockSysUserModel)(nil).TransactCtx), ctx, fn)
}

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

// Update indicates an expected call of Update.
func (mr *MockSysUserModelMockRecorder) Update(ctx, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSysUserModel)(nil).Update), ctx, data)
}

// UpdatePassword mocks base method.
func (m *MockSysUserModel) UpdatePassword(ctx context.Context, id int64, username, password string, mustChangePassword, expectedUpdateTime int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePassword", ctx, id, username, password, mustChangePassword, expectedUpdateTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdatePassword indicates an expected call of UpdatePassword.
func (mr *MockSysUserModelMockRecorder) UpdatePassword(ctx, id, username, password, mustChangePassword, expectedUpdateTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePassword", reflect.TypeOf((*MockSysUserModel)(nil).UpdatePassword), ctx, id, username, password, mustChangePassword, expectedUpdateTime)
}

// UpdateProfile mocks base method.
func (m *MockSysUserModel) UpdateProfile(ctx context.Context, id int64, username, nickname, email, phone, remark string, deptId, newStatus int64, statusChanged bool, expectedUpdateTime int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProfile", ctx, id, username, nickname, email, phone, remark, deptId, newStatus, statusChanged, expectedUpdateTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProfile indicates an expected call of UpdateProfile.
func (mr *MockSysUserModelMockRecorder) UpdateProfile(ctx, id, username, nickname, email, phone, remark, deptId, newStatus, statusChanged, expectedUpdateTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProfile", reflect.TypeOf((*MockSysUserModel)(nil).UpdateProfile), ctx, id, username, nickname, email, phone, remark, deptId, newStatus, statusChanged, expectedUpdateTime)
}

// UpdateProfileWithTx mocks base method.
func (m *MockSysUserModel) UpdateProfileWithTx(ctx context.Context, session sqlx.Session, id int64, username, nickname, email, phone, remark string, deptId, newStatus int64, statusChanged bool, expectedUpdateTime int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProfileWithTx", ctx, session, id, username, nickname, email, phone, remark, deptId, newStatus, statusChanged, expectedUpdateTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProfileWithTx indicates an expected call of UpdateProfileWithTx.
func (mr *MockSysUserModelMockRecorder) UpdateProfileWithTx(ctx, session, id, username, nickname, email, phone, remark, deptId, newStatus, statusChanged, expectedUpdateTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProfileWithTx", reflect.TypeOf((*MockSysUserModel)(nil).UpdateProfileWithTx), ctx, session, id, username, nickname, email, phone, remark, deptId, newStatus, statusChanged, expectedUpdateTime)
}

// UpdateSelfInfo mocks base method.
func (m *MockSysUserModel) UpdateSelfInfo(ctx context.Context, id int64, username, nickname, avatar, email, phone string, expectedUpdateTime int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSelfInfo", ctx, id, username, nickname, avatar, email, phone, expectedUpdateTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSelfInfo indicates an expected call of UpdateSelfInfo.
func (mr *MockSysUserModelMockRecorder) UpdateSelfInfo(ctx, id, username, nickname, avatar, email, phone, expectedUpdateTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSelfInfo", reflect.TypeOf((*MockSysUserModel)(nil).UpdateSelfInfo), ctx, id, username, nickname, avatar, email, phone, expectedUpdateTime)
}

// UpdateStatus mocks base method.
func (m *MockSysUserModel) UpdateStatus(ctx context.Context, id int64, username string, status, expectedUpdateTime int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateStatus", ctx, id, username, status, expectedUpdateTime)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStatus indicates an expected call of UpdateStatus.
func (mr *MockSysUserModelMockRecorder) UpdateStatus(ctx, id, username, status, expectedUpdateTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStatus", reflect.TypeOf((*MockSysUserModel)(nil).UpdateStatus), ctx, id, username, status, expectedUpdateTime)
}

// UpdateWithTx mocks base method.
func (m *MockSysUserModel) UpdateWithTx(ctx context.Context, session sqlx.Session, data *user.SysUser) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWithTx", ctx, session, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWithTx indicates an expected call of UpdateWithTx.
func (mr *MockSysUserModelMockRecorder) UpdateWithTx(ctx, session, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWithTx", reflect.TypeOf((*MockSysUserModel)(nil).UpdateWithTx), ctx, session, data)
}