zitadel/backend/v3/domain/mock/human_user.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: HumanUserRepository)
//
// Generated by this command:
//
//	mockgen -typed -package domainmock -destination ./mock/human_user.mock.go . HumanUserRepository
//

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

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

	domain "github.com/zitadel/zitadel/backend/v3/domain"
	database "github.com/zitadel/zitadel/backend/v3/storage/database"
	crypto "github.com/zitadel/zitadel/internal/crypto"
	gomock "go.uber.org/mock/gomock"
	language "golang.org/x/text/language"
)

// MockHumanUserRepository is a mock of HumanUserRepository interface.
type MockHumanUserRepository struct {
	ctrl     *gomock.Controller
	recorder *MockHumanUserRepositoryMockRecorder
	isgomock struct{}
}

// MockHumanUserRepositoryMockRecorder is the mock recorder for MockHumanUserRepository.
type MockHumanUserRepositoryMockRecorder struct {
	mock *MockHumanUserRepository
}

// NewMockHumanUserRepository creates a new mock instance.
func NewMockHumanUserRepository(ctrl *gomock.Controller) *MockHumanUserRepository {
	mock := &MockHumanUserRepository{ctrl: ctrl}
	mock.recorder = &MockHumanUserRepositoryMockRecorder{mock}
	return mock
}

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

// AddIdentityProviderLink mocks base method.
func (m *MockHumanUserRepository) AddIdentityProviderLink(link *domain.IdentityProviderLink) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddIdentityProviderLink", link)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// AddIdentityProviderLink indicates an expected call of AddIdentityProviderLink.
func (mr *MockHumanUserRepositoryMockRecorder) AddIdentityProviderLink(link any) *MockHumanUserRepositoryAddIdentityProviderLinkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddIdentityProviderLink", reflect.TypeOf((*MockHumanUserRepository)(nil).AddIdentityProviderLink), link)
	return &MockHumanUserRepositoryAddIdentityProviderLinkCall{Call: call}
}

// MockHumanUserRepositoryAddIdentityProviderLinkCall wrap *gomock.Call
type MockHumanUserRepositoryAddIdentityProviderLinkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryAddIdentityProviderLinkCall) Return(arg0 database.Change) *MockHumanUserRepositoryAddIdentityProviderLinkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryAddIdentityProviderLinkCall) Do(f func(*domain.IdentityProviderLink) database.Change) *MockHumanUserRepositoryAddIdentityProviderLinkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryAddIdentityProviderLinkCall) DoAndReturn(f func(*domain.IdentityProviderLink) database.Change) *MockHumanUserRepositoryAddIdentityProviderLinkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddPasskey mocks base method.
func (m *MockHumanUserRepository) AddPasskey(passkey *domain.Passkey) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPasskey", passkey)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// AddPasskey indicates an expected call of AddPasskey.
func (mr *MockHumanUserRepositoryMockRecorder) AddPasskey(passkey any) *MockHumanUserRepositoryAddPasskeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPasskey", reflect.TypeOf((*MockHumanUserRepository)(nil).AddPasskey), passkey)
	return &MockHumanUserRepositoryAddPasskeyCall{Call: call}
}

// MockHumanUserRepositoryAddPasskeyCall wrap *gomock.Call
type MockHumanUserRepositoryAddPasskeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryAddPasskeyCall) Return(arg0 database.Change) *MockHumanUserRepositoryAddPasskeyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryAddPasskeyCall) Do(f func(*domain.Passkey) database.Change) *MockHumanUserRepositoryAddPasskeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryAddPasskeyCall) DoAndReturn(f func(*domain.Passkey) database.Change) *MockHumanUserRepositoryAddPasskeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// AddRecoveryCodes indicates an expected call of AddRecoveryCodes.
func (mr *MockHumanUserRepositoryMockRecorder) AddRecoveryCodes(codes any) *MockHumanUserRepositoryAddRecoveryCodesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRecoveryCodes", reflect.TypeOf((*MockHumanUserRepository)(nil).AddRecoveryCodes), codes)
	return &MockHumanUserRepositoryAddRecoveryCodesCall{Call: call}
}

// MockHumanUserRepositoryAddRecoveryCodesCall wrap *gomock.Call
type MockHumanUserRepositoryAddRecoveryCodesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryAddRecoveryCodesCall) Return(arg0 database.Change) *MockHumanUserRepositoryAddRecoveryCodesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryAddRecoveryCodesCall) Do(f func([]string) database.Change) *MockHumanUserRepositoryAddRecoveryCodesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryAddRecoveryCodesCall) DoAndReturn(f func([]string) database.Change) *MockHumanUserRepositoryAddRecoveryCodesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreatedAtColumn mocks base method.
func (m *MockHumanUserRepository) CreatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// CreatedAtColumn indicates an expected call of CreatedAtColumn.
func (mr *MockHumanUserRepositoryMockRecorder) CreatedAtColumn() *MockHumanUserRepositoryCreatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).CreatedAtColumn))
	return &MockHumanUserRepositoryCreatedAtColumnCall{Call: call}
}

// MockHumanUserRepositoryCreatedAtColumnCall wrap *gomock.Call
type MockHumanUserRepositoryCreatedAtColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryCreatedAtColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryCreatedAtColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryCreatedAtColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DisableEmailOTP mocks base method.
func (m *MockHumanUserRepository) DisableEmailOTP() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableEmailOTP")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// DisableEmailOTP indicates an expected call of DisableEmailOTP.
func (mr *MockHumanUserRepositoryMockRecorder) DisableEmailOTP() *MockHumanUserRepositoryDisableEmailOTPCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEmailOTP", reflect.TypeOf((*MockHumanUserRepository)(nil).DisableEmailOTP))
	return &MockHumanUserRepositoryDisableEmailOTPCall{Call: call}
}

// MockHumanUserRepositoryDisableEmailOTPCall wrap *gomock.Call
type MockHumanUserRepositoryDisableEmailOTPCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryDisableEmailOTPCall) Return(arg0 database.Change) *MockHumanUserRepositoryDisableEmailOTPCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryDisableEmailOTPCall) Do(f func() database.Change) *MockHumanUserRepositoryDisableEmailOTPCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryDisableEmailOTPCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryDisableEmailOTPCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DisableSMSOTP mocks base method.
func (m *MockHumanUserRepository) DisableSMSOTP() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableSMSOTP")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// DisableSMSOTP indicates an expected call of DisableSMSOTP.
func (mr *MockHumanUserRepositoryMockRecorder) DisableSMSOTP() *MockHumanUserRepositoryDisableSMSOTPCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSMSOTP", reflect.TypeOf((*MockHumanUserRepository)(nil).DisableSMSOTP))
	return &MockHumanUserRepositoryDisableSMSOTPCall{Call: call}
}

// MockHumanUserRepositoryDisableSMSOTPCall wrap *gomock.Call
type MockHumanUserRepositoryDisableSMSOTPCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryDisableSMSOTPCall) Return(arg0 database.Change) *MockHumanUserRepositoryDisableSMSOTPCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryDisableSMSOTPCall) Do(f func() database.Change) *MockHumanUserRepositoryDisableSMSOTPCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryDisableSMSOTPCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryDisableSMSOTPCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DisplayNameColumn mocks base method.
func (m *MockHumanUserRepository) DisplayNameColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisplayNameColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// DisplayNameColumn indicates an expected call of DisplayNameColumn.
func (mr *MockHumanUserRepositoryMockRecorder) DisplayNameColumn() *MockHumanUserRepositoryDisplayNameColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisplayNameColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).DisplayNameColumn))
	return &MockHumanUserRepositoryDisplayNameColumnCall{Call: call}
}

// MockHumanUserRepositoryDisplayNameColumnCall wrap *gomock.Call
type MockHumanUserRepositoryDisplayNameColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryDisplayNameColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryDisplayNameColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryDisplayNameColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryDisplayNameColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryDisplayNameColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryDisplayNameColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DisplayNameCondition mocks base method.
func (m *MockHumanUserRepository) DisplayNameCondition(op database.TextOperation, displayName string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisplayNameCondition", op, displayName)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// DisplayNameCondition indicates an expected call of DisplayNameCondition.
func (mr *MockHumanUserRepositoryMockRecorder) DisplayNameCondition(op, displayName any) *MockHumanUserRepositoryDisplayNameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisplayNameCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).DisplayNameCondition), op, displayName)
	return &MockHumanUserRepositoryDisplayNameConditionCall{Call: call}
}

// MockHumanUserRepositoryDisplayNameConditionCall wrap *gomock.Call
type MockHumanUserRepositoryDisplayNameConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryDisplayNameConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryDisplayNameConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryDisplayNameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryDisplayNameConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryDisplayNameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryDisplayNameConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EmailColumn mocks base method.
func (m *MockHumanUserRepository) EmailColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EmailColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// EmailColumn indicates an expected call of EmailColumn.
func (mr *MockHumanUserRepositoryMockRecorder) EmailColumn() *MockHumanUserRepositoryEmailColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EmailColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).EmailColumn))
	return &MockHumanUserRepositoryEmailColumnCall{Call: call}
}

// MockHumanUserRepositoryEmailColumnCall wrap *gomock.Call
type MockHumanUserRepositoryEmailColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryEmailColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryEmailColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryEmailColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryEmailColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryEmailColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryEmailColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EmailCondition mocks base method.
func (m *MockHumanUserRepository) EmailCondition(op database.TextOperation, email string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EmailCondition", op, email)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// EmailCondition indicates an expected call of EmailCondition.
func (mr *MockHumanUserRepositoryMockRecorder) EmailCondition(op, email any) *MockHumanUserRepositoryEmailConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EmailCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).EmailCondition), op, email)
	return &MockHumanUserRepositoryEmailConditionCall{Call: call}
}

// MockHumanUserRepositoryEmailConditionCall wrap *gomock.Call
type MockHumanUserRepositoryEmailConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryEmailConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryEmailConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryEmailConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryEmailConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryEmailConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryEmailConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EnableEmailOTP mocks base method.
func (m *MockHumanUserRepository) EnableEmailOTP() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableEmailOTP")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// EnableEmailOTP indicates an expected call of EnableEmailOTP.
func (mr *MockHumanUserRepositoryMockRecorder) EnableEmailOTP() *MockHumanUserRepositoryEnableEmailOTPCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEmailOTP", reflect.TypeOf((*MockHumanUserRepository)(nil).EnableEmailOTP))
	return &MockHumanUserRepositoryEnableEmailOTPCall{Call: call}
}

// MockHumanUserRepositoryEnableEmailOTPCall wrap *gomock.Call
type MockHumanUserRepositoryEnableEmailOTPCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryEnableEmailOTPCall) Return(arg0 database.Change) *MockHumanUserRepositoryEnableEmailOTPCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryEnableEmailOTPCall) Do(f func() database.Change) *MockHumanUserRepositoryEnableEmailOTPCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryEnableEmailOTPCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryEnableEmailOTPCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EnableEmailOTPAt mocks base method.
func (m *MockHumanUserRepository) EnableEmailOTPAt(enabledAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableEmailOTPAt", enabledAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// EnableEmailOTPAt indicates an expected call of EnableEmailOTPAt.
func (mr *MockHumanUserRepositoryMockRecorder) EnableEmailOTPAt(enabledAt any) *MockHumanUserRepositoryEnableEmailOTPAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEmailOTPAt", reflect.TypeOf((*MockHumanUserRepository)(nil).EnableEmailOTPAt), enabledAt)
	return &MockHumanUserRepositoryEnableEmailOTPAtCall{Call: call}
}

// MockHumanUserRepositoryEnableEmailOTPAtCall wrap *gomock.Call
type MockHumanUserRepositoryEnableEmailOTPAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryEnableEmailOTPAtCall) Return(arg0 database.Change) *MockHumanUserRepositoryEnableEmailOTPAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryEnableEmailOTPAtCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositoryEnableEmailOTPAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryEnableEmailOTPAtCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositoryEnableEmailOTPAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EnableSMSOTP mocks base method.
func (m *MockHumanUserRepository) EnableSMSOTP() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSMSOTP")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// EnableSMSOTP indicates an expected call of EnableSMSOTP.
func (mr *MockHumanUserRepositoryMockRecorder) EnableSMSOTP() *MockHumanUserRepositoryEnableSMSOTPCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSMSOTP", reflect.TypeOf((*MockHumanUserRepository)(nil).EnableSMSOTP))
	return &MockHumanUserRepositoryEnableSMSOTPCall{Call: call}
}

// MockHumanUserRepositoryEnableSMSOTPCall wrap *gomock.Call
type MockHumanUserRepositoryEnableSMSOTPCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryEnableSMSOTPCall) Return(arg0 database.Change) *MockHumanUserRepositoryEnableSMSOTPCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryEnableSMSOTPCall) Do(f func() database.Change) *MockHumanUserRepositoryEnableSMSOTPCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryEnableSMSOTPCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryEnableSMSOTPCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EnableSMSOTPAt mocks base method.
func (m *MockHumanUserRepository) EnableSMSOTPAt(enabledAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSMSOTPAt", enabledAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// EnableSMSOTPAt indicates an expected call of EnableSMSOTPAt.
func (mr *MockHumanUserRepositoryMockRecorder) EnableSMSOTPAt(enabledAt any) *MockHumanUserRepositoryEnableSMSOTPAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSMSOTPAt", reflect.TypeOf((*MockHumanUserRepository)(nil).EnableSMSOTPAt), enabledAt)
	return &MockHumanUserRepositoryEnableSMSOTPAtCall{Call: call}
}

// MockHumanUserRepositoryEnableSMSOTPAtCall wrap *gomock.Call
type MockHumanUserRepositoryEnableSMSOTPAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryEnableSMSOTPAtCall) Return(arg0 database.Change) *MockHumanUserRepositoryEnableSMSOTPAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryEnableSMSOTPAtCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositoryEnableSMSOTPAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryEnableSMSOTPAtCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositoryEnableSMSOTPAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ExistsIdentityProviderLink mocks base method.
func (m *MockHumanUserRepository) ExistsIdentityProviderLink(condition database.Condition) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistsIdentityProviderLink", condition)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ExistsIdentityProviderLink indicates an expected call of ExistsIdentityProviderLink.
func (mr *MockHumanUserRepositoryMockRecorder) ExistsIdentityProviderLink(condition any) *MockHumanUserRepositoryExistsIdentityProviderLinkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsIdentityProviderLink", reflect.TypeOf((*MockHumanUserRepository)(nil).ExistsIdentityProviderLink), condition)
	return &MockHumanUserRepositoryExistsIdentityProviderLinkCall{Call: call}
}

// MockHumanUserRepositoryExistsIdentityProviderLinkCall wrap *gomock.Call
type MockHumanUserRepositoryExistsIdentityProviderLinkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryExistsIdentityProviderLinkCall) Return(arg0 database.Condition) *MockHumanUserRepositoryExistsIdentityProviderLinkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryExistsIdentityProviderLinkCall) Do(f func(database.Condition) database.Condition) *MockHumanUserRepositoryExistsIdentityProviderLinkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryExistsIdentityProviderLinkCall) DoAndReturn(f func(database.Condition) database.Condition) *MockHumanUserRepositoryExistsIdentityProviderLinkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ExistsMetadata mocks base method.
func (m *MockHumanUserRepository) ExistsMetadata(condition database.Condition) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistsMetadata", condition)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ExistsMetadata indicates an expected call of ExistsMetadata.
func (mr *MockHumanUserRepositoryMockRecorder) ExistsMetadata(condition any) *MockHumanUserRepositoryExistsMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsMetadata", reflect.TypeOf((*MockHumanUserRepository)(nil).ExistsMetadata), condition)
	return &MockHumanUserRepositoryExistsMetadataCall{Call: call}
}

// MockHumanUserRepositoryExistsMetadataCall wrap *gomock.Call
type MockHumanUserRepositoryExistsMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryExistsMetadataCall) Return(arg0 database.Condition) *MockHumanUserRepositoryExistsMetadataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryExistsMetadataCall) Do(f func(database.Condition) database.Condition) *MockHumanUserRepositoryExistsMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryExistsMetadataCall) DoAndReturn(f func(database.Condition) database.Condition) *MockHumanUserRepositoryExistsMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ExistsPasskey mocks base method.
func (m *MockHumanUserRepository) ExistsPasskey(condition database.Condition) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistsPasskey", condition)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ExistsPasskey indicates an expected call of ExistsPasskey.
func (mr *MockHumanUserRepositoryMockRecorder) ExistsPasskey(condition any) *MockHumanUserRepositoryExistsPasskeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsPasskey", reflect.TypeOf((*MockHumanUserRepository)(nil).ExistsPasskey), condition)
	return &MockHumanUserRepositoryExistsPasskeyCall{Call: call}
}

// MockHumanUserRepositoryExistsPasskeyCall wrap *gomock.Call
type MockHumanUserRepositoryExistsPasskeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryExistsPasskeyCall) Return(arg0 database.Condition) *MockHumanUserRepositoryExistsPasskeyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryExistsPasskeyCall) Do(f func(database.Condition) database.Condition) *MockHumanUserRepositoryExistsPasskeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryExistsPasskeyCall) DoAndReturn(f func(database.Condition) database.Condition) *MockHumanUserRepositoryExistsPasskeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FirstNameColumn mocks base method.
func (m *MockHumanUserRepository) FirstNameColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FirstNameColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// FirstNameColumn indicates an expected call of FirstNameColumn.
func (mr *MockHumanUserRepositoryMockRecorder) FirstNameColumn() *MockHumanUserRepositoryFirstNameColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FirstNameColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).FirstNameColumn))
	return &MockHumanUserRepositoryFirstNameColumnCall{Call: call}
}

// MockHumanUserRepositoryFirstNameColumnCall wrap *gomock.Call
type MockHumanUserRepositoryFirstNameColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryFirstNameColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryFirstNameColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryFirstNameColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryFirstNameColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryFirstNameColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryFirstNameColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FirstNameCondition mocks base method.
func (m *MockHumanUserRepository) FirstNameCondition(op database.TextOperation, firstName string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FirstNameCondition", op, firstName)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// FirstNameCondition indicates an expected call of FirstNameCondition.
func (mr *MockHumanUserRepositoryMockRecorder) FirstNameCondition(op, firstName any) *MockHumanUserRepositoryFirstNameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FirstNameCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).FirstNameCondition), op, firstName)
	return &MockHumanUserRepositoryFirstNameConditionCall{Call: call}
}

// MockHumanUserRepositoryFirstNameConditionCall wrap *gomock.Call
type MockHumanUserRepositoryFirstNameConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryFirstNameConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryFirstNameConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryFirstNameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryFirstNameConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryFirstNameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryFirstNameConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IDColumn mocks base method.
func (m *MockHumanUserRepository) IDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// IDColumn indicates an expected call of IDColumn.
func (mr *MockHumanUserRepositoryMockRecorder) IDColumn() *MockHumanUserRepositoryIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).IDColumn))
	return &MockHumanUserRepositoryIDColumnCall{Call: call}
}

// MockHumanUserRepositoryIDColumnCall wrap *gomock.Call
type MockHumanUserRepositoryIDColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryIDColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryIDColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// IDCondition indicates an expected call of IDCondition.
func (mr *MockHumanUserRepositoryMockRecorder) IDCondition(userID any) *MockHumanUserRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).IDCondition), userID)
	return &MockHumanUserRepositoryIDConditionCall{Call: call}
}

// MockHumanUserRepositoryIDConditionCall wrap *gomock.Call
type MockHumanUserRepositoryIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryIDConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockHumanUserRepositoryIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockHumanUserRepositoryIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IdentityProviderLinkConditions mocks base method.
func (m *MockHumanUserRepository) IdentityProviderLinkConditions() domain.HumanIdentityProviderLinkConditions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IdentityProviderLinkConditions")
	ret0, _ := ret[0].(domain.HumanIdentityProviderLinkConditions)
	return ret0
}

// IdentityProviderLinkConditions indicates an expected call of IdentityProviderLinkConditions.
func (mr *MockHumanUserRepositoryMockRecorder) IdentityProviderLinkConditions() *MockHumanUserRepositoryIdentityProviderLinkConditionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityProviderLinkConditions", reflect.TypeOf((*MockHumanUserRepository)(nil).IdentityProviderLinkConditions))
	return &MockHumanUserRepositoryIdentityProviderLinkConditionsCall{Call: call}
}

// MockHumanUserRepositoryIdentityProviderLinkConditionsCall wrap *gomock.Call
type MockHumanUserRepositoryIdentityProviderLinkConditionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryIdentityProviderLinkConditionsCall) Return(arg0 domain.HumanIdentityProviderLinkConditions) *MockHumanUserRepositoryIdentityProviderLinkConditionsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryIdentityProviderLinkConditionsCall) Do(f func() domain.HumanIdentityProviderLinkConditions) *MockHumanUserRepositoryIdentityProviderLinkConditionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIdentityProviderLinkConditionsCall) DoAndReturn(f func() domain.HumanIdentityProviderLinkConditions) *MockHumanUserRepositoryIdentityProviderLinkConditionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IncrementEmailOTPFailedAttempts mocks base method.
func (m *MockHumanUserRepository) IncrementEmailOTPFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementEmailOTPFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// IncrementEmailOTPFailedAttempts indicates an expected call of IncrementEmailOTPFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) IncrementEmailOTPFailedAttempts() *MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementEmailOTPFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).IncrementEmailOTPFailedAttempts))
	return &MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryIncrementEmailOTPFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IncrementPasswordFailedAttempts mocks base method.
func (m *MockHumanUserRepository) IncrementPasswordFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementPasswordFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// IncrementPasswordFailedAttempts indicates an expected call of IncrementPasswordFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) IncrementPasswordFailedAttempts() *MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementPasswordFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).IncrementPasswordFailedAttempts))
	return &MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryIncrementPasswordFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IncrementRecoveryCodeFailedAttempts mocks base method.
func (m *MockHumanUserRepository) IncrementRecoveryCodeFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementRecoveryCodeFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// IncrementRecoveryCodeFailedAttempts indicates an expected call of IncrementRecoveryCodeFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) IncrementRecoveryCodeFailedAttempts() *MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementRecoveryCodeFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).IncrementRecoveryCodeFailedAttempts))
	return &MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryIncrementRecoveryCodeFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IncrementSMSOTPFailedAttempts mocks base method.
func (m *MockHumanUserRepository) IncrementSMSOTPFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementSMSOTPFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// IncrementSMSOTPFailedAttempts indicates an expected call of IncrementSMSOTPFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) IncrementSMSOTPFailedAttempts() *MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementSMSOTPFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).IncrementSMSOTPFailedAttempts))
	return &MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryIncrementSMSOTPFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IncrementTOTPFailedAttempts mocks base method.
func (m *MockHumanUserRepository) IncrementTOTPFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementTOTPFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// IncrementTOTPFailedAttempts indicates an expected call of IncrementTOTPFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) IncrementTOTPFailedAttempts() *MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementTOTPFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).IncrementTOTPFailedAttempts))
	return &MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryIncrementTOTPFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// InstanceIDColumn mocks base method.
func (m *MockHumanUserRepository) InstanceIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// InstanceIDColumn indicates an expected call of InstanceIDColumn.
func (mr *MockHumanUserRepositoryMockRecorder) InstanceIDColumn() *MockHumanUserRepositoryInstanceIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).InstanceIDColumn))
	return &MockHumanUserRepositoryInstanceIDColumnCall{Call: call}
}

// MockHumanUserRepositoryInstanceIDColumnCall wrap *gomock.Call
type MockHumanUserRepositoryInstanceIDColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryInstanceIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryInstanceIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryInstanceIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockHumanUserRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockHumanUserRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).InstanceIDCondition), instanceID)
	return &MockHumanUserRepositoryInstanceIDConditionCall{Call: call}
}

// MockHumanUserRepositoryInstanceIDConditionCall wrap *gomock.Call
type MockHumanUserRepositoryInstanceIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryInstanceIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockHumanUserRepositoryInstanceIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockHumanUserRepositoryInstanceIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LastNameColumn mocks base method.
func (m *MockHumanUserRepository) LastNameColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LastNameColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// LastNameColumn indicates an expected call of LastNameColumn.
func (mr *MockHumanUserRepositoryMockRecorder) LastNameColumn() *MockHumanUserRepositoryLastNameColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastNameColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).LastNameColumn))
	return &MockHumanUserRepositoryLastNameColumnCall{Call: call}
}

// MockHumanUserRepositoryLastNameColumnCall wrap *gomock.Call
type MockHumanUserRepositoryLastNameColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryLastNameColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryLastNameColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryLastNameColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryLastNameColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryLastNameColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryLastNameColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LastNameCondition mocks base method.
func (m *MockHumanUserRepository) LastNameCondition(op database.TextOperation, lastName string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LastNameCondition", op, lastName)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// LastNameCondition indicates an expected call of LastNameCondition.
func (mr *MockHumanUserRepositoryMockRecorder) LastNameCondition(op, lastName any) *MockHumanUserRepositoryLastNameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastNameCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).LastNameCondition), op, lastName)
	return &MockHumanUserRepositoryLastNameConditionCall{Call: call}
}

// MockHumanUserRepositoryLastNameConditionCall wrap *gomock.Call
type MockHumanUserRepositoryLastNameConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryLastNameConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryLastNameConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryLastNameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryLastNameConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryLastNameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryLastNameConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoginNameCondition mocks base method.
func (m *MockHumanUserRepository) LoginNameCondition(op database.TextOperation, loginName string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoginNameCondition", op, loginName)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// LoginNameCondition indicates an expected call of LoginNameCondition.
func (mr *MockHumanUserRepositoryMockRecorder) LoginNameCondition(op, loginName any) *MockHumanUserRepositoryLoginNameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoginNameCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).LoginNameCondition), op, loginName)
	return &MockHumanUserRepositoryLoginNameConditionCall{Call: call}
}

// MockHumanUserRepositoryLoginNameConditionCall wrap *gomock.Call
type MockHumanUserRepositoryLoginNameConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryLoginNameConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryLoginNameConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryLoginNameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryLoginNameConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryLoginNameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryLoginNameConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MetadataConditions mocks base method.
func (m *MockHumanUserRepository) MetadataConditions() domain.UserMetadataConditions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MetadataConditions")
	ret0, _ := ret[0].(domain.UserMetadataConditions)
	return ret0
}

// MetadataConditions indicates an expected call of MetadataConditions.
func (mr *MockHumanUserRepositoryMockRecorder) MetadataConditions() *MockHumanUserRepositoryMetadataConditionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataConditions", reflect.TypeOf((*MockHumanUserRepository)(nil).MetadataConditions))
	return &MockHumanUserRepositoryMetadataConditionsCall{Call: call}
}

// MockHumanUserRepositoryMetadataConditionsCall wrap *gomock.Call
type MockHumanUserRepositoryMetadataConditionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryMetadataConditionsCall) Return(arg0 domain.UserMetadataConditions) *MockHumanUserRepositoryMetadataConditionsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryMetadataConditionsCall) Do(f func() domain.UserMetadataConditions) *MockHumanUserRepositoryMetadataConditionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryMetadataConditionsCall) DoAndReturn(f func() domain.UserMetadataConditions) *MockHumanUserRepositoryMetadataConditionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NicknameColumn mocks base method.
func (m *MockHumanUserRepository) NicknameColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NicknameColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// NicknameColumn indicates an expected call of NicknameColumn.
func (mr *MockHumanUserRepositoryMockRecorder) NicknameColumn() *MockHumanUserRepositoryNicknameColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NicknameColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).NicknameColumn))
	return &MockHumanUserRepositoryNicknameColumnCall{Call: call}
}

// MockHumanUserRepositoryNicknameColumnCall wrap *gomock.Call
type MockHumanUserRepositoryNicknameColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryNicknameColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryNicknameColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryNicknameColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryNicknameColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryNicknameColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryNicknameColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NicknameCondition mocks base method.
func (m *MockHumanUserRepository) NicknameCondition(op database.TextOperation, nickname string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NicknameCondition", op, nickname)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// NicknameCondition indicates an expected call of NicknameCondition.
func (mr *MockHumanUserRepositoryMockRecorder) NicknameCondition(op, nickname any) *MockHumanUserRepositoryNicknameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NicknameCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).NicknameCondition), op, nickname)
	return &MockHumanUserRepositoryNicknameConditionCall{Call: call}
}

// MockHumanUserRepositoryNicknameConditionCall wrap *gomock.Call
type MockHumanUserRepositoryNicknameConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryNicknameConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryNicknameConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryNicknameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryNicknameConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryNicknameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryNicknameConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
func (mr *MockHumanUserRepositoryMockRecorder) OrganizationIDCondition(orgID any) *MockHumanUserRepositoryOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).OrganizationIDCondition), orgID)
	return &MockHumanUserRepositoryOrganizationIDConditionCall{Call: call}
}

// MockHumanUserRepositoryOrganizationIDConditionCall wrap *gomock.Call
type MockHumanUserRepositoryOrganizationIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryOrganizationIDConditionCall) Do(f func(string) database.Condition) *MockHumanUserRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryOrganizationIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockHumanUserRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PasskeyConditions mocks base method.
func (m *MockHumanUserRepository) PasskeyConditions() domain.HumanPasskeyConditions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PasskeyConditions")
	ret0, _ := ret[0].(domain.HumanPasskeyConditions)
	return ret0
}

// PasskeyConditions indicates an expected call of PasskeyConditions.
func (mr *MockHumanUserRepositoryMockRecorder) PasskeyConditions() *MockHumanUserRepositoryPasskeyConditionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasskeyConditions", reflect.TypeOf((*MockHumanUserRepository)(nil).PasskeyConditions))
	return &MockHumanUserRepositoryPasskeyConditionsCall{Call: call}
}

// MockHumanUserRepositoryPasskeyConditionsCall wrap *gomock.Call
type MockHumanUserRepositoryPasskeyConditionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryPasskeyConditionsCall) Return(arg0 domain.HumanPasskeyConditions) *MockHumanUserRepositoryPasskeyConditionsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryPasskeyConditionsCall) Do(f func() domain.HumanPasskeyConditions) *MockHumanUserRepositoryPasskeyConditionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryPasskeyConditionsCall) DoAndReturn(f func() domain.HumanPasskeyConditions) *MockHumanUserRepositoryPasskeyConditionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PhoneCondition mocks base method.
func (m *MockHumanUserRepository) PhoneCondition(op database.TextOperation, phone string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PhoneCondition", op, phone)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// PhoneCondition indicates an expected call of PhoneCondition.
func (mr *MockHumanUserRepositoryMockRecorder) PhoneCondition(op, phone any) *MockHumanUserRepositoryPhoneConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PhoneCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).PhoneCondition), op, phone)
	return &MockHumanUserRepositoryPhoneConditionCall{Call: call}
}

// MockHumanUserRepositoryPhoneConditionCall wrap *gomock.Call
type MockHumanUserRepositoryPhoneConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryPhoneConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryPhoneConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryPhoneConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryPhoneConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryPhoneConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryPhoneConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PreferredLanguageCondition mocks base method.
func (m *MockHumanUserRepository) PreferredLanguageCondition(lang language.Tag) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreferredLanguageCondition", lang)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// PreferredLanguageCondition indicates an expected call of PreferredLanguageCondition.
func (mr *MockHumanUserRepositoryMockRecorder) PreferredLanguageCondition(lang any) *MockHumanUserRepositoryPreferredLanguageConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreferredLanguageCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).PreferredLanguageCondition), lang)
	return &MockHumanUserRepositoryPreferredLanguageConditionCall{Call: call}
}

// MockHumanUserRepositoryPreferredLanguageConditionCall wrap *gomock.Call
type MockHumanUserRepositoryPreferredLanguageConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryPreferredLanguageConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryPreferredLanguageConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryPreferredLanguageConditionCall) Do(f func(language.Tag) database.Condition) *MockHumanUserRepositoryPreferredLanguageConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryPreferredLanguageConditionCall) DoAndReturn(f func(language.Tag) database.Condition) *MockHumanUserRepositoryPreferredLanguageConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PrimaryKeyColumns mocks base method.
func (m *MockHumanUserRepository) PrimaryKeyColumns() []database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyColumns")
	ret0, _ := ret[0].([]database.Column)
	return ret0
}

// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns.
func (mr *MockHumanUserRepositoryMockRecorder) PrimaryKeyColumns() *MockHumanUserRepositoryPrimaryKeyColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockHumanUserRepository)(nil).PrimaryKeyColumns))
	return &MockHumanUserRepositoryPrimaryKeyColumnsCall{Call: call}
}

// MockHumanUserRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
type MockHumanUserRepositoryPrimaryKeyColumnsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockHumanUserRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockHumanUserRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockHumanUserRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PrimaryKeyCondition mocks base method.
func (m *MockHumanUserRepository) PrimaryKeyCondition(instanceID, userID string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, userID)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
func (mr *MockHumanUserRepositoryMockRecorder) PrimaryKeyCondition(instanceID, userID any) *MockHumanUserRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).PrimaryKeyCondition), instanceID, userID)
	return &MockHumanUserRepositoryPrimaryKeyConditionCall{Call: call}
}

// MockHumanUserRepositoryPrimaryKeyConditionCall wrap *gomock.Call
type MockHumanUserRepositoryPrimaryKeyConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockHumanUserRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockHumanUserRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RemoveAllRecoveryCodes mocks base method.
func (m *MockHumanUserRepository) RemoveAllRecoveryCodes() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveAllRecoveryCodes")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// RemoveAllRecoveryCodes indicates an expected call of RemoveAllRecoveryCodes.
func (mr *MockHumanUserRepositoryMockRecorder) RemoveAllRecoveryCodes() *MockHumanUserRepositoryRemoveAllRecoveryCodesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAllRecoveryCodes", reflect.TypeOf((*MockHumanUserRepository)(nil).RemoveAllRecoveryCodes))
	return &MockHumanUserRepositoryRemoveAllRecoveryCodesCall{Call: call}
}

// MockHumanUserRepositoryRemoveAllRecoveryCodesCall wrap *gomock.Call
type MockHumanUserRepositoryRemoveAllRecoveryCodesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryRemoveAllRecoveryCodesCall) Return(arg0 database.Change) *MockHumanUserRepositoryRemoveAllRecoveryCodesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryRemoveAllRecoveryCodesCall) Do(f func() database.Change) *MockHumanUserRepositoryRemoveAllRecoveryCodesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryRemoveAllRecoveryCodesCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryRemoveAllRecoveryCodesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RemoveIdentityProviderLink mocks base method.
func (m *MockHumanUserRepository) RemoveIdentityProviderLink(providerID, providedUserID string) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveIdentityProviderLink", providerID, providedUserID)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// RemoveIdentityProviderLink indicates an expected call of RemoveIdentityProviderLink.
func (mr *MockHumanUserRepositoryMockRecorder) RemoveIdentityProviderLink(providerID, providedUserID any) *MockHumanUserRepositoryRemoveIdentityProviderLinkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveIdentityProviderLink", reflect.TypeOf((*MockHumanUserRepository)(nil).RemoveIdentityProviderLink), providerID, providedUserID)
	return &MockHumanUserRepositoryRemoveIdentityProviderLinkCall{Call: call}
}

// MockHumanUserRepositoryRemoveIdentityProviderLinkCall wrap *gomock.Call
type MockHumanUserRepositoryRemoveIdentityProviderLinkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryRemoveIdentityProviderLinkCall) Return(arg0 database.Change) *MockHumanUserRepositoryRemoveIdentityProviderLinkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryRemoveIdentityProviderLinkCall) Do(f func(string, string) database.Change) *MockHumanUserRepositoryRemoveIdentityProviderLinkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryRemoveIdentityProviderLinkCall) DoAndReturn(f func(string, string) database.Change) *MockHumanUserRepositoryRemoveIdentityProviderLinkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RemoveMetadata mocks base method.
func (m *MockHumanUserRepository) RemoveMetadata(condition database.Condition) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveMetadata", condition)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// RemoveMetadata indicates an expected call of RemoveMetadata.
func (mr *MockHumanUserRepositoryMockRecorder) RemoveMetadata(condition any) *MockHumanUserRepositoryRemoveMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMetadata", reflect.TypeOf((*MockHumanUserRepository)(nil).RemoveMetadata), condition)
	return &MockHumanUserRepositoryRemoveMetadataCall{Call: call}
}

// MockHumanUserRepositoryRemoveMetadataCall wrap *gomock.Call
type MockHumanUserRepositoryRemoveMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryRemoveMetadataCall) Return(arg0 database.Change) *MockHumanUserRepositoryRemoveMetadataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryRemoveMetadataCall) Do(f func(database.Condition) database.Change) *MockHumanUserRepositoryRemoveMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryRemoveMetadataCall) DoAndReturn(f func(database.Condition) database.Change) *MockHumanUserRepositoryRemoveMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RemovePasskey mocks base method.
func (m *MockHumanUserRepository) RemovePasskey(condition database.Condition) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePasskey", condition)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// RemovePasskey indicates an expected call of RemovePasskey.
func (mr *MockHumanUserRepositoryMockRecorder) RemovePasskey(condition any) *MockHumanUserRepositoryRemovePasskeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePasskey", reflect.TypeOf((*MockHumanUserRepository)(nil).RemovePasskey), condition)
	return &MockHumanUserRepositoryRemovePasskeyCall{Call: call}
}

// MockHumanUserRepositoryRemovePasskeyCall wrap *gomock.Call
type MockHumanUserRepositoryRemovePasskeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryRemovePasskeyCall) Return(arg0 database.Change) *MockHumanUserRepositoryRemovePasskeyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryRemovePasskeyCall) Do(f func(database.Condition) database.Change) *MockHumanUserRepositoryRemovePasskeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryRemovePasskeyCall) DoAndReturn(f func(database.Condition) database.Change) *MockHumanUserRepositoryRemovePasskeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RemovePhone mocks base method.
func (m *MockHumanUserRepository) RemovePhone() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePhone")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// RemovePhone indicates an expected call of RemovePhone.
func (mr *MockHumanUserRepositoryMockRecorder) RemovePhone() *MockHumanUserRepositoryRemovePhoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePhone", reflect.TypeOf((*MockHumanUserRepository)(nil).RemovePhone))
	return &MockHumanUserRepositoryRemovePhoneCall{Call: call}
}

// MockHumanUserRepositoryRemovePhoneCall wrap *gomock.Call
type MockHumanUserRepositoryRemovePhoneCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryRemovePhoneCall) Return(arg0 database.Change) *MockHumanUserRepositoryRemovePhoneCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryRemovePhoneCall) Do(f func() database.Change) *MockHumanUserRepositoryRemovePhoneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryRemovePhoneCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryRemovePhoneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveRecoveryCode indicates an expected call of RemoveRecoveryCode.
func (mr *MockHumanUserRepositoryMockRecorder) RemoveRecoveryCode(code any) *MockHumanUserRepositoryRemoveRecoveryCodeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRecoveryCode", reflect.TypeOf((*MockHumanUserRepository)(nil).RemoveRecoveryCode), code)
	return &MockHumanUserRepositoryRemoveRecoveryCodeCall{Call: call}
}

// MockHumanUserRepositoryRemoveRecoveryCodeCall wrap *gomock.Call
type MockHumanUserRepositoryRemoveRecoveryCodeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryRemoveRecoveryCodeCall) Return(arg0 database.Change) *MockHumanUserRepositoryRemoveRecoveryCodeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryRemoveRecoveryCodeCall) Do(f func(string) database.Change) *MockHumanUserRepositoryRemoveRecoveryCodeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryRemoveRecoveryCodeCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositoryRemoveRecoveryCodeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RemoveTOTP mocks base method.
func (m *MockHumanUserRepository) RemoveTOTP() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTOTP")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// RemoveTOTP indicates an expected call of RemoveTOTP.
func (mr *MockHumanUserRepositoryMockRecorder) RemoveTOTP() *MockHumanUserRepositoryRemoveTOTPCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTOTP", reflect.TypeOf((*MockHumanUserRepository)(nil).RemoveTOTP))
	return &MockHumanUserRepositoryRemoveTOTPCall{Call: call}
}

// MockHumanUserRepositoryRemoveTOTPCall wrap *gomock.Call
type MockHumanUserRepositoryRemoveTOTPCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryRemoveTOTPCall) Return(arg0 database.Change) *MockHumanUserRepositoryRemoveTOTPCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryRemoveTOTPCall) Do(f func() database.Change) *MockHumanUserRepositoryRemoveTOTPCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryRemoveTOTPCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryRemoveTOTPCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ResetEmailOTPFailedAttempts mocks base method.
func (m *MockHumanUserRepository) ResetEmailOTPFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetEmailOTPFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// ResetEmailOTPFailedAttempts indicates an expected call of ResetEmailOTPFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) ResetEmailOTPFailedAttempts() *MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEmailOTPFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).ResetEmailOTPFailedAttempts))
	return &MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryResetEmailOTPFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ResetPasswordFailedAttempts mocks base method.
func (m *MockHumanUserRepository) ResetPasswordFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetPasswordFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// ResetPasswordFailedAttempts indicates an expected call of ResetPasswordFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) ResetPasswordFailedAttempts() *MockHumanUserRepositoryResetPasswordFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPasswordFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).ResetPasswordFailedAttempts))
	return &MockHumanUserRepositoryResetPasswordFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryResetPasswordFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryResetPasswordFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryResetPasswordFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryResetPasswordFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryResetPasswordFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryResetPasswordFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryResetPasswordFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryResetPasswordFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ResetRecoveryCodeFailedAttempts mocks base method.
func (m *MockHumanUserRepository) ResetRecoveryCodeFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetRecoveryCodeFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// ResetRecoveryCodeFailedAttempts indicates an expected call of ResetRecoveryCodeFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) ResetRecoveryCodeFailedAttempts() *MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetRecoveryCodeFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).ResetRecoveryCodeFailedAttempts))
	return &MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryResetRecoveryCodeFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ResetSMSOTPFailedAttempts mocks base method.
func (m *MockHumanUserRepository) ResetSMSOTPFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetSMSOTPFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// ResetSMSOTPFailedAttempts indicates an expected call of ResetSMSOTPFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) ResetSMSOTPFailedAttempts() *MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSMSOTPFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).ResetSMSOTPFailedAttempts))
	return &MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryResetSMSOTPFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ResetTOTPFailedAttempts mocks base method.
func (m *MockHumanUserRepository) ResetTOTPFailedAttempts() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetTOTPFailedAttempts")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// ResetTOTPFailedAttempts indicates an expected call of ResetTOTPFailedAttempts.
func (mr *MockHumanUserRepositoryMockRecorder) ResetTOTPFailedAttempts() *MockHumanUserRepositoryResetTOTPFailedAttemptsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetTOTPFailedAttempts", reflect.TypeOf((*MockHumanUserRepository)(nil).ResetTOTPFailedAttempts))
	return &MockHumanUserRepositoryResetTOTPFailedAttemptsCall{Call: call}
}

// MockHumanUserRepositoryResetTOTPFailedAttemptsCall wrap *gomock.Call
type MockHumanUserRepositoryResetTOTPFailedAttemptsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryResetTOTPFailedAttemptsCall) Return(arg0 database.Change) *MockHumanUserRepositoryResetTOTPFailedAttemptsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryResetTOTPFailedAttemptsCall) Do(f func() database.Change) *MockHumanUserRepositoryResetTOTPFailedAttemptsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryResetTOTPFailedAttemptsCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositoryResetTOTPFailedAttemptsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetAvatarKey indicates an expected call of SetAvatarKey.
func (mr *MockHumanUserRepositoryMockRecorder) SetAvatarKey(avatarKey any) *MockHumanUserRepositorySetAvatarKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAvatarKey", reflect.TypeOf((*MockHumanUserRepository)(nil).SetAvatarKey), avatarKey)
	return &MockHumanUserRepositorySetAvatarKeyCall{Call: call}
}

// MockHumanUserRepositorySetAvatarKeyCall wrap *gomock.Call
type MockHumanUserRepositorySetAvatarKeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetAvatarKeyCall) Return(arg0 database.Change) *MockHumanUserRepositorySetAvatarKeyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetAvatarKeyCall) Do(f func(*string) database.Change) *MockHumanUserRepositorySetAvatarKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetAvatarKeyCall) DoAndReturn(f func(*string) database.Change) *MockHumanUserRepositorySetAvatarKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetDisplayName indicates an expected call of SetDisplayName.
func (mr *MockHumanUserRepositoryMockRecorder) SetDisplayName(displayName any) *MockHumanUserRepositorySetDisplayNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDisplayName", reflect.TypeOf((*MockHumanUserRepository)(nil).SetDisplayName), displayName)
	return &MockHumanUserRepositorySetDisplayNameCall{Call: call}
}

// MockHumanUserRepositorySetDisplayNameCall wrap *gomock.Call
type MockHumanUserRepositorySetDisplayNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetDisplayNameCall) Return(arg0 database.Change) *MockHumanUserRepositorySetDisplayNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetDisplayNameCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetDisplayNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetDisplayNameCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetDisplayNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetEmail indicates an expected call of SetEmail.
func (mr *MockHumanUserRepositoryMockRecorder) SetEmail(address any) *MockHumanUserRepositorySetEmailCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEmail", reflect.TypeOf((*MockHumanUserRepository)(nil).SetEmail), address)
	return &MockHumanUserRepositorySetEmailCall{Call: call}
}

// MockHumanUserRepositorySetEmailCall wrap *gomock.Call
type MockHumanUserRepositorySetEmailCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetEmailCall) Return(arg0 database.Change) *MockHumanUserRepositorySetEmailCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetEmailCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetEmailCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetEmailCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetEmailCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetEmailVerification mocks base method.
func (m *MockHumanUserRepository) SetEmailVerification(verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEmailVerification", verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetEmailVerification indicates an expected call of SetEmailVerification.
func (mr *MockHumanUserRepositoryMockRecorder) SetEmailVerification(verification any) *MockHumanUserRepositorySetEmailVerificationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEmailVerification", reflect.TypeOf((*MockHumanUserRepository)(nil).SetEmailVerification), verification)
	return &MockHumanUserRepositorySetEmailVerificationCall{Call: call}
}

// MockHumanUserRepositorySetEmailVerificationCall wrap *gomock.Call
type MockHumanUserRepositorySetEmailVerificationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetEmailVerificationCall) Return(arg0 database.Change) *MockHumanUserRepositorySetEmailVerificationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetEmailVerificationCall) Do(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetEmailVerificationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetEmailVerificationCall) DoAndReturn(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetEmailVerificationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetFirstName indicates an expected call of SetFirstName.
func (mr *MockHumanUserRepositoryMockRecorder) SetFirstName(firstName any) *MockHumanUserRepositorySetFirstNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFirstName", reflect.TypeOf((*MockHumanUserRepository)(nil).SetFirstName), firstName)
	return &MockHumanUserRepositorySetFirstNameCall{Call: call}
}

// MockHumanUserRepositorySetFirstNameCall wrap *gomock.Call
type MockHumanUserRepositorySetFirstNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetFirstNameCall) Return(arg0 database.Change) *MockHumanUserRepositorySetFirstNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetFirstNameCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetFirstNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetFirstNameCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetFirstNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetGender mocks base method.
func (m *MockHumanUserRepository) SetGender(gender domain.HumanGender) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetGender", gender)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetGender indicates an expected call of SetGender.
func (mr *MockHumanUserRepositoryMockRecorder) SetGender(gender any) *MockHumanUserRepositorySetGenderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGender", reflect.TypeOf((*MockHumanUserRepository)(nil).SetGender), gender)
	return &MockHumanUserRepositorySetGenderCall{Call: call}
}

// MockHumanUserRepositorySetGenderCall wrap *gomock.Call
type MockHumanUserRepositorySetGenderCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetGenderCall) Return(arg0 database.Change) *MockHumanUserRepositorySetGenderCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetGenderCall) Do(f func(domain.HumanGender) database.Change) *MockHumanUserRepositorySetGenderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetGenderCall) DoAndReturn(f func(domain.HumanGender) database.Change) *MockHumanUserRepositorySetGenderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetIdentityProviderLinkProvidedID indicates an expected call of SetIdentityProviderLinkProvidedID.
func (mr *MockHumanUserRepositoryMockRecorder) SetIdentityProviderLinkProvidedID(providedUserID any) *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIdentityProviderLinkProvidedID", reflect.TypeOf((*MockHumanUserRepository)(nil).SetIdentityProviderLinkProvidedID), providedUserID)
	return &MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall{Call: call}
}

// MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall wrap *gomock.Call
type MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall) Return(arg0 database.Change) *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetIdentityProviderLinkUsername indicates an expected call of SetIdentityProviderLinkUsername.
func (mr *MockHumanUserRepositoryMockRecorder) SetIdentityProviderLinkUsername(username any) *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIdentityProviderLinkUsername", reflect.TypeOf((*MockHumanUserRepository)(nil).SetIdentityProviderLinkUsername), username)
	return &MockHumanUserRepositorySetIdentityProviderLinkUsernameCall{Call: call}
}

// MockHumanUserRepositorySetIdentityProviderLinkUsernameCall wrap *gomock.Call
type MockHumanUserRepositorySetIdentityProviderLinkUsernameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall) Return(arg0 database.Change) *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetInviteVerification mocks base method.
func (m *MockHumanUserRepository) SetInviteVerification(verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInviteVerification", verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetInviteVerification indicates an expected call of SetInviteVerification.
func (mr *MockHumanUserRepositoryMockRecorder) SetInviteVerification(verification any) *MockHumanUserRepositorySetInviteVerificationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInviteVerification", reflect.TypeOf((*MockHumanUserRepository)(nil).SetInviteVerification), verification)
	return &MockHumanUserRepositorySetInviteVerificationCall{Call: call}
}

// MockHumanUserRepositorySetInviteVerificationCall wrap *gomock.Call
type MockHumanUserRepositorySetInviteVerificationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetInviteVerificationCall) Return(arg0 database.Change) *MockHumanUserRepositorySetInviteVerificationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetInviteVerificationCall) Do(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetInviteVerificationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetInviteVerificationCall) DoAndReturn(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetInviteVerificationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetLastName indicates an expected call of SetLastName.
func (mr *MockHumanUserRepositoryMockRecorder) SetLastName(lastName any) *MockHumanUserRepositorySetLastNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastName", reflect.TypeOf((*MockHumanUserRepository)(nil).SetLastName), lastName)
	return &MockHumanUserRepositorySetLastNameCall{Call: call}
}

// MockHumanUserRepositorySetLastNameCall wrap *gomock.Call
type MockHumanUserRepositorySetLastNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetLastNameCall) Return(arg0 database.Change) *MockHumanUserRepositorySetLastNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetLastNameCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetLastNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetLastNameCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetLastNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLastSuccessfulEmailOTPCheck mocks base method.
func (m *MockHumanUserRepository) SetLastSuccessfulEmailOTPCheck(checkedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLastSuccessfulEmailOTPCheck", checkedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetLastSuccessfulEmailOTPCheck indicates an expected call of SetLastSuccessfulEmailOTPCheck.
func (mr *MockHumanUserRepositoryMockRecorder) SetLastSuccessfulEmailOTPCheck(checkedAt any) *MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastSuccessfulEmailOTPCheck", reflect.TypeOf((*MockHumanUserRepository)(nil).SetLastSuccessfulEmailOTPCheck), checkedAt)
	return &MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall{Call: call}
}

// MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall wrap *gomock.Call
type MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall) Return(arg0 database.Change) *MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulEmailOTPCheckCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLastSuccessfulPasswordCheck mocks base method.
func (m *MockHumanUserRepository) SetLastSuccessfulPasswordCheck(checkedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLastSuccessfulPasswordCheck", checkedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetLastSuccessfulPasswordCheck indicates an expected call of SetLastSuccessfulPasswordCheck.
func (mr *MockHumanUserRepositoryMockRecorder) SetLastSuccessfulPasswordCheck(checkedAt any) *MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastSuccessfulPasswordCheck", reflect.TypeOf((*MockHumanUserRepository)(nil).SetLastSuccessfulPasswordCheck), checkedAt)
	return &MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall{Call: call}
}

// MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall wrap *gomock.Call
type MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall) Return(arg0 database.Change) *MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulPasswordCheckCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLastSuccessfulRecoveryCodeCheck mocks base method.
func (m *MockHumanUserRepository) SetLastSuccessfulRecoveryCodeCheck(checkedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLastSuccessfulRecoveryCodeCheck", checkedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetLastSuccessfulRecoveryCodeCheck indicates an expected call of SetLastSuccessfulRecoveryCodeCheck.
func (mr *MockHumanUserRepositoryMockRecorder) SetLastSuccessfulRecoveryCodeCheck(checkedAt any) *MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastSuccessfulRecoveryCodeCheck", reflect.TypeOf((*MockHumanUserRepository)(nil).SetLastSuccessfulRecoveryCodeCheck), checkedAt)
	return &MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall{Call: call}
}

// MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall wrap *gomock.Call
type MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall) Return(arg0 database.Change) *MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulRecoveryCodeCheckCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLastSuccessfulSMSOTPCheck mocks base method.
func (m *MockHumanUserRepository) SetLastSuccessfulSMSOTPCheck(checkedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLastSuccessfulSMSOTPCheck", checkedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetLastSuccessfulSMSOTPCheck indicates an expected call of SetLastSuccessfulSMSOTPCheck.
func (mr *MockHumanUserRepositoryMockRecorder) SetLastSuccessfulSMSOTPCheck(checkedAt any) *MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastSuccessfulSMSOTPCheck", reflect.TypeOf((*MockHumanUserRepository)(nil).SetLastSuccessfulSMSOTPCheck), checkedAt)
	return &MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall{Call: call}
}

// MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall wrap *gomock.Call
type MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall) Return(arg0 database.Change) *MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulSMSOTPCheckCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLastSuccessfulTOTPCheck mocks base method.
func (m *MockHumanUserRepository) SetLastSuccessfulTOTPCheck(checkedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLastSuccessfulTOTPCheck", checkedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetLastSuccessfulTOTPCheck indicates an expected call of SetLastSuccessfulTOTPCheck.
func (mr *MockHumanUserRepositoryMockRecorder) SetLastSuccessfulTOTPCheck(checkedAt any) *MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastSuccessfulTOTPCheck", reflect.TypeOf((*MockHumanUserRepository)(nil).SetLastSuccessfulTOTPCheck), checkedAt)
	return &MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall{Call: call}
}

// MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall wrap *gomock.Call
type MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall) Return(arg0 database.Change) *MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetLastSuccessfulTOTPCheckCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetMetadata mocks base method.
func (m *MockHumanUserRepository) SetMetadata(metadata ...*domain.Metadata) database.Change {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range metadata {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetMetadata", varargs...)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetMetadata indicates an expected call of SetMetadata.
func (mr *MockHumanUserRepositoryMockRecorder) SetMetadata(metadata ...any) *MockHumanUserRepositorySetMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockHumanUserRepository)(nil).SetMetadata), metadata...)
	return &MockHumanUserRepositorySetMetadataCall{Call: call}
}

// MockHumanUserRepositorySetMetadataCall wrap *gomock.Call
type MockHumanUserRepositorySetMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetMetadataCall) Return(arg0 database.Change) *MockHumanUserRepositorySetMetadataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetMetadataCall) Do(f func(...*domain.Metadata) database.Change) *MockHumanUserRepositorySetMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetMetadataCall) DoAndReturn(f func(...*domain.Metadata) database.Change) *MockHumanUserRepositorySetMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetNickname indicates an expected call of SetNickname.
func (mr *MockHumanUserRepositoryMockRecorder) SetNickname(nickname any) *MockHumanUserRepositorySetNicknameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNickname", reflect.TypeOf((*MockHumanUserRepository)(nil).SetNickname), nickname)
	return &MockHumanUserRepositorySetNicknameCall{Call: call}
}

// MockHumanUserRepositorySetNicknameCall wrap *gomock.Call
type MockHumanUserRepositorySetNicknameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetNicknameCall) Return(arg0 database.Change) *MockHumanUserRepositorySetNicknameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetNicknameCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetNicknameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetNicknameCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetNicknameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetPasskeyAttestationType indicates an expected call of SetPasskeyAttestationType.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasskeyAttestationType(attestationType any) *MockHumanUserRepositorySetPasskeyAttestationTypeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasskeyAttestationType", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasskeyAttestationType), attestationType)
	return &MockHumanUserRepositorySetPasskeyAttestationTypeCall{Call: call}
}

// MockHumanUserRepositorySetPasskeyAttestationTypeCall wrap *gomock.Call
type MockHumanUserRepositorySetPasskeyAttestationTypeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasskeyAttestationTypeCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasskeyAttestationTypeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasskeyAttestationTypeCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetPasskeyAttestationTypeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasskeyAttestationTypeCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetPasskeyAttestationTypeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasskeyAuthenticatorAttestationGUID mocks base method.
func (m *MockHumanUserRepository) SetPasskeyAuthenticatorAttestationGUID(aaguid []byte) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasskeyAuthenticatorAttestationGUID", aaguid)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPasskeyAuthenticatorAttestationGUID indicates an expected call of SetPasskeyAuthenticatorAttestationGUID.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasskeyAuthenticatorAttestationGUID(aaguid any) *MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasskeyAuthenticatorAttestationGUID", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasskeyAuthenticatorAttestationGUID), aaguid)
	return &MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall{Call: call}
}

// MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall wrap *gomock.Call
type MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall) Do(f func([]byte) database.Change) *MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall) DoAndReturn(f func([]byte) database.Change) *MockHumanUserRepositorySetPasskeyAuthenticatorAttestationGUIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasskeyKeyID mocks base method.
func (m *MockHumanUserRepository) SetPasskeyKeyID(keyID []byte) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasskeyKeyID", keyID)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPasskeyKeyID indicates an expected call of SetPasskeyKeyID.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasskeyKeyID(keyID any) *MockHumanUserRepositorySetPasskeyKeyIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasskeyKeyID", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasskeyKeyID), keyID)
	return &MockHumanUserRepositorySetPasskeyKeyIDCall{Call: call}
}

// MockHumanUserRepositorySetPasskeyKeyIDCall wrap *gomock.Call
type MockHumanUserRepositorySetPasskeyKeyIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasskeyKeyIDCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasskeyKeyIDCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasskeyKeyIDCall) Do(f func([]byte) database.Change) *MockHumanUserRepositorySetPasskeyKeyIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasskeyKeyIDCall) DoAndReturn(f func([]byte) database.Change) *MockHumanUserRepositorySetPasskeyKeyIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetPasskeyName indicates an expected call of SetPasskeyName.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasskeyName(name any) *MockHumanUserRepositorySetPasskeyNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasskeyName", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasskeyName), name)
	return &MockHumanUserRepositorySetPasskeyNameCall{Call: call}
}

// MockHumanUserRepositorySetPasskeyNameCall wrap *gomock.Call
type MockHumanUserRepositorySetPasskeyNameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasskeyNameCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasskeyNameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasskeyNameCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetPasskeyNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasskeyNameCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetPasskeyNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasskeyPublicKey mocks base method.
func (m *MockHumanUserRepository) SetPasskeyPublicKey(publicKey []byte) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasskeyPublicKey", publicKey)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPasskeyPublicKey indicates an expected call of SetPasskeyPublicKey.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasskeyPublicKey(publicKey any) *MockHumanUserRepositorySetPasskeyPublicKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasskeyPublicKey", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasskeyPublicKey), publicKey)
	return &MockHumanUserRepositorySetPasskeyPublicKeyCall{Call: call}
}

// MockHumanUserRepositorySetPasskeyPublicKeyCall wrap *gomock.Call
type MockHumanUserRepositorySetPasskeyPublicKeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasskeyPublicKeyCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasskeyPublicKeyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasskeyPublicKeyCall) Do(f func([]byte) database.Change) *MockHumanUserRepositorySetPasskeyPublicKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasskeyPublicKeyCall) DoAndReturn(f func([]byte) database.Change) *MockHumanUserRepositorySetPasskeyPublicKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasskeySignCount mocks base method.
func (m *MockHumanUserRepository) SetPasskeySignCount(signCount uint32) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasskeySignCount", signCount)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPasskeySignCount indicates an expected call of SetPasskeySignCount.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasskeySignCount(signCount any) *MockHumanUserRepositorySetPasskeySignCountCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasskeySignCount", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasskeySignCount), signCount)
	return &MockHumanUserRepositorySetPasskeySignCountCall{Call: call}
}

// MockHumanUserRepositorySetPasskeySignCountCall wrap *gomock.Call
type MockHumanUserRepositorySetPasskeySignCountCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasskeySignCountCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasskeySignCountCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasskeySignCountCall) Do(f func(uint32) database.Change) *MockHumanUserRepositorySetPasskeySignCountCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasskeySignCountCall) DoAndReturn(f func(uint32) database.Change) *MockHumanUserRepositorySetPasskeySignCountCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasskeyUpdatedAt mocks base method.
func (m *MockHumanUserRepository) SetPasskeyUpdatedAt(updatedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasskeyUpdatedAt", updatedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPasskeyUpdatedAt indicates an expected call of SetPasskeyUpdatedAt.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasskeyUpdatedAt(updatedAt any) *MockHumanUserRepositorySetPasskeyUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasskeyUpdatedAt", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasskeyUpdatedAt), updatedAt)
	return &MockHumanUserRepositorySetPasskeyUpdatedAtCall{Call: call}
}

// MockHumanUserRepositorySetPasskeyUpdatedAtCall wrap *gomock.Call
type MockHumanUserRepositorySetPasskeyUpdatedAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasskeyUpdatedAtCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasskeyUpdatedAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasskeyUpdatedAtCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetPasskeyUpdatedAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasskeyUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetPasskeyUpdatedAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasskeyVerifiedAt mocks base method.
func (m *MockHumanUserRepository) SetPasskeyVerifiedAt(verifiedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasskeyVerifiedAt", verifiedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPasskeyVerifiedAt indicates an expected call of SetPasskeyVerifiedAt.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasskeyVerifiedAt(verifiedAt any) *MockHumanUserRepositorySetPasskeyVerifiedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasskeyVerifiedAt", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasskeyVerifiedAt), verifiedAt)
	return &MockHumanUserRepositorySetPasskeyVerifiedAtCall{Call: call}
}

// MockHumanUserRepositorySetPasskeyVerifiedAtCall wrap *gomock.Call
type MockHumanUserRepositorySetPasskeyVerifiedAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasskeyVerifiedAtCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasskeyVerifiedAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasskeyVerifiedAtCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetPasskeyVerifiedAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasskeyVerifiedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetPasskeyVerifiedAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetPassword indicates an expected call of SetPassword.
func (mr *MockHumanUserRepositoryMockRecorder) SetPassword(hash any) *MockHumanUserRepositorySetPasswordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPassword", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPassword), hash)
	return &MockHumanUserRepositorySetPasswordCall{Call: call}
}

// MockHumanUserRepositorySetPasswordCall wrap *gomock.Call
type MockHumanUserRepositorySetPasswordCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasswordCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasswordCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasswordCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetPasswordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasswordCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetPasswordCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasswordChangeRequired mocks base method.
func (m *MockHumanUserRepository) SetPasswordChangeRequired(required bool) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasswordChangeRequired", required)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPasswordChangeRequired indicates an expected call of SetPasswordChangeRequired.
func (mr *MockHumanUserRepositoryMockRecorder) SetPasswordChangeRequired(required any) *MockHumanUserRepositorySetPasswordChangeRequiredCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordChangeRequired", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPasswordChangeRequired), required)
	return &MockHumanUserRepositorySetPasswordChangeRequiredCall{Call: call}
}

// MockHumanUserRepositorySetPasswordChangeRequiredCall wrap *gomock.Call
type MockHumanUserRepositorySetPasswordChangeRequiredCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPasswordChangeRequiredCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPasswordChangeRequiredCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPasswordChangeRequiredCall) Do(f func(bool) database.Change) *MockHumanUserRepositorySetPasswordChangeRequiredCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasswordChangeRequiredCall) DoAndReturn(f func(bool) database.Change) *MockHumanUserRepositorySetPasswordChangeRequiredCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetPhone indicates an expected call of SetPhone.
func (mr *MockHumanUserRepositoryMockRecorder) SetPhone(number any) *MockHumanUserRepositorySetPhoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPhone", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPhone), number)
	return &MockHumanUserRepositorySetPhoneCall{Call: call}
}

// MockHumanUserRepositorySetPhoneCall wrap *gomock.Call
type MockHumanUserRepositorySetPhoneCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPhoneCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPhoneCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPhoneCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetPhoneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPhoneCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetPhoneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPhoneVerification mocks base method.
func (m *MockHumanUserRepository) SetPhoneVerification(verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPhoneVerification", verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPhoneVerification indicates an expected call of SetPhoneVerification.
func (mr *MockHumanUserRepositoryMockRecorder) SetPhoneVerification(verification any) *MockHumanUserRepositorySetPhoneVerificationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPhoneVerification", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPhoneVerification), verification)
	return &MockHumanUserRepositorySetPhoneVerificationCall{Call: call}
}

// MockHumanUserRepositorySetPhoneVerificationCall wrap *gomock.Call
type MockHumanUserRepositorySetPhoneVerificationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPhoneVerificationCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPhoneVerificationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPhoneVerificationCall) Do(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetPhoneVerificationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPhoneVerificationCall) DoAndReturn(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetPhoneVerificationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPreferredLanguage mocks base method.
func (m *MockHumanUserRepository) SetPreferredLanguage(preferredLanguage language.Tag) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPreferredLanguage", preferredLanguage)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPreferredLanguage indicates an expected call of SetPreferredLanguage.
func (mr *MockHumanUserRepositoryMockRecorder) SetPreferredLanguage(preferredLanguage any) *MockHumanUserRepositorySetPreferredLanguageCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPreferredLanguage", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPreferredLanguage), preferredLanguage)
	return &MockHumanUserRepositorySetPreferredLanguageCall{Call: call}
}

// MockHumanUserRepositorySetPreferredLanguageCall wrap *gomock.Call
type MockHumanUserRepositorySetPreferredLanguageCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetPreferredLanguageCall) Return(arg0 database.Change) *MockHumanUserRepositorySetPreferredLanguageCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetPreferredLanguageCall) Do(f func(language.Tag) database.Change) *MockHumanUserRepositorySetPreferredLanguageCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPreferredLanguageCall) DoAndReturn(f func(language.Tag) database.Change) *MockHumanUserRepositorySetPreferredLanguageCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetResetPasswordVerification mocks base method.
func (m *MockHumanUserRepository) SetResetPasswordVerification(verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetResetPasswordVerification", verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetResetPasswordVerification indicates an expected call of SetResetPasswordVerification.
func (mr *MockHumanUserRepositoryMockRecorder) SetResetPasswordVerification(verification any) *MockHumanUserRepositorySetResetPasswordVerificationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetResetPasswordVerification", reflect.TypeOf((*MockHumanUserRepository)(nil).SetResetPasswordVerification), verification)
	return &MockHumanUserRepositorySetResetPasswordVerificationCall{Call: call}
}

// MockHumanUserRepositorySetResetPasswordVerificationCall wrap *gomock.Call
type MockHumanUserRepositorySetResetPasswordVerificationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetResetPasswordVerificationCall) Return(arg0 database.Change) *MockHumanUserRepositorySetResetPasswordVerificationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetResetPasswordVerificationCall) Do(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetResetPasswordVerificationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetResetPasswordVerificationCall) DoAndReturn(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetResetPasswordVerificationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetState mocks base method.
func (m *MockHumanUserRepository) SetState(state domain.UserState) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetState", state)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetState indicates an expected call of SetState.
func (mr *MockHumanUserRepositoryMockRecorder) SetState(state any) *MockHumanUserRepositorySetStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockHumanUserRepository)(nil).SetState), state)
	return &MockHumanUserRepositorySetStateCall{Call: call}
}

// MockHumanUserRepositorySetStateCall wrap *gomock.Call
type MockHumanUserRepositorySetStateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetStateCall) Return(arg0 database.Change) *MockHumanUserRepositorySetStateCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetStateCall) Do(f func(domain.UserState) database.Change) *MockHumanUserRepositorySetStateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetStateCall) DoAndReturn(f func(domain.UserState) database.Change) *MockHumanUserRepositorySetStateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetTOTPSecret mocks base method.
func (m *MockHumanUserRepository) SetTOTPSecret(secret *crypto.CryptoValue) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTOTPSecret", secret)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetTOTPSecret indicates an expected call of SetTOTPSecret.
func (mr *MockHumanUserRepositoryMockRecorder) SetTOTPSecret(secret any) *MockHumanUserRepositorySetTOTPSecretCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTOTPSecret", reflect.TypeOf((*MockHumanUserRepository)(nil).SetTOTPSecret), secret)
	return &MockHumanUserRepositorySetTOTPSecretCall{Call: call}
}

// MockHumanUserRepositorySetTOTPSecretCall wrap *gomock.Call
type MockHumanUserRepositorySetTOTPSecretCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetTOTPSecretCall) Return(arg0 database.Change) *MockHumanUserRepositorySetTOTPSecretCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetTOTPSecretCall) Do(f func(*crypto.CryptoValue) database.Change) *MockHumanUserRepositorySetTOTPSecretCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetTOTPSecretCall) DoAndReturn(f func(*crypto.CryptoValue) database.Change) *MockHumanUserRepositorySetTOTPSecretCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetTOTPVerifiedAt mocks base method.
func (m *MockHumanUserRepository) SetTOTPVerifiedAt(verifiedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTOTPVerifiedAt", verifiedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetTOTPVerifiedAt indicates an expected call of SetTOTPVerifiedAt.
func (mr *MockHumanUserRepositoryMockRecorder) SetTOTPVerifiedAt(verifiedAt any) *MockHumanUserRepositorySetTOTPVerifiedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTOTPVerifiedAt", reflect.TypeOf((*MockHumanUserRepository)(nil).SetTOTPVerifiedAt), verifiedAt)
	return &MockHumanUserRepositorySetTOTPVerifiedAtCall{Call: call}
}

// MockHumanUserRepositorySetTOTPVerifiedAtCall wrap *gomock.Call
type MockHumanUserRepositorySetTOTPVerifiedAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetTOTPVerifiedAtCall) Return(arg0 database.Change) *MockHumanUserRepositorySetTOTPVerifiedAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetTOTPVerifiedAtCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetTOTPVerifiedAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetTOTPVerifiedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetTOTPVerifiedAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetUnverifiedEmail indicates an expected call of SetUnverifiedEmail.
func (mr *MockHumanUserRepositoryMockRecorder) SetUnverifiedEmail(address any) *MockHumanUserRepositorySetUnverifiedEmailCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUnverifiedEmail", reflect.TypeOf((*MockHumanUserRepository)(nil).SetUnverifiedEmail), address)
	return &MockHumanUserRepositorySetUnverifiedEmailCall{Call: call}
}

// MockHumanUserRepositorySetUnverifiedEmailCall wrap *gomock.Call
type MockHumanUserRepositorySetUnverifiedEmailCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetUnverifiedEmailCall) Return(arg0 database.Change) *MockHumanUserRepositorySetUnverifiedEmailCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetUnverifiedEmailCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetUnverifiedEmailCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetUnverifiedEmailCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetUnverifiedEmailCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetUnverifiedPhone indicates an expected call of SetUnverifiedPhone.
func (mr *MockHumanUserRepositoryMockRecorder) SetUnverifiedPhone(number any) *MockHumanUserRepositorySetUnverifiedPhoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUnverifiedPhone", reflect.TypeOf((*MockHumanUserRepository)(nil).SetUnverifiedPhone), number)
	return &MockHumanUserRepositorySetUnverifiedPhoneCall{Call: call}
}

// MockHumanUserRepositorySetUnverifiedPhoneCall wrap *gomock.Call
type MockHumanUserRepositorySetUnverifiedPhoneCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetUnverifiedPhoneCall) Return(arg0 database.Change) *MockHumanUserRepositorySetUnverifiedPhoneCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetUnverifiedPhoneCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetUnverifiedPhoneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetUnverifiedPhoneCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetUnverifiedPhoneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetUpdatedAt mocks base method.
func (m *MockHumanUserRepository) SetUpdatedAt(updatedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockHumanUserRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockHumanUserRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockHumanUserRepository)(nil).SetUpdatedAt), updatedAt)
	return &MockHumanUserRepositorySetUpdatedAtCall{Call: call}
}

// MockHumanUserRepositorySetUpdatedAtCall wrap *gomock.Call
type MockHumanUserRepositorySetUpdatedAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockHumanUserRepositorySetUpdatedAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetUpdatedAtCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySetUpdatedAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetUpdatedAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetUsername indicates an expected call of SetUsername.
func (mr *MockHumanUserRepositoryMockRecorder) SetUsername(username any) *MockHumanUserRepositorySetUsernameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUsername", reflect.TypeOf((*MockHumanUserRepository)(nil).SetUsername), username)
	return &MockHumanUserRepositorySetUsernameCall{Call: call}
}

// MockHumanUserRepositorySetUsernameCall wrap *gomock.Call
type MockHumanUserRepositorySetUsernameCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetUsernameCall) Return(arg0 database.Change) *MockHumanUserRepositorySetUsernameCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetUsernameCall) Do(f func(string) database.Change) *MockHumanUserRepositorySetUsernameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetUsernameCall) DoAndReturn(f func(string) database.Change) *MockHumanUserRepositorySetUsernameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetVerification mocks base method.
func (m *MockHumanUserRepository) SetVerification(verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVerification", verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetVerification indicates an expected call of SetVerification.
func (mr *MockHumanUserRepositoryMockRecorder) SetVerification(verification any) *MockHumanUserRepositorySetVerificationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVerification", reflect.TypeOf((*MockHumanUserRepository)(nil).SetVerification), verification)
	return &MockHumanUserRepositorySetVerificationCall{Call: call}
}

// MockHumanUserRepositorySetVerificationCall wrap *gomock.Call
type MockHumanUserRepositorySetVerificationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySetVerificationCall) Return(arg0 database.Change) *MockHumanUserRepositorySetVerificationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySetVerificationCall) Do(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetVerificationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetVerificationCall) DoAndReturn(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetVerificationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SkipMultifactorInitialization mocks base method.
func (m *MockHumanUserRepository) SkipMultifactorInitialization() database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SkipMultifactorInitialization")
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SkipMultifactorInitialization indicates an expected call of SkipMultifactorInitialization.
func (mr *MockHumanUserRepositoryMockRecorder) SkipMultifactorInitialization() *MockHumanUserRepositorySkipMultifactorInitializationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SkipMultifactorInitialization", reflect.TypeOf((*MockHumanUserRepository)(nil).SkipMultifactorInitialization))
	return &MockHumanUserRepositorySkipMultifactorInitializationCall{Call: call}
}

// MockHumanUserRepositorySkipMultifactorInitializationCall wrap *gomock.Call
type MockHumanUserRepositorySkipMultifactorInitializationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySkipMultifactorInitializationCall) Return(arg0 database.Change) *MockHumanUserRepositorySkipMultifactorInitializationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySkipMultifactorInitializationCall) Do(f func() database.Change) *MockHumanUserRepositorySkipMultifactorInitializationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySkipMultifactorInitializationCall) DoAndReturn(f func() database.Change) *MockHumanUserRepositorySkipMultifactorInitializationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SkipMultifactorInitializationAt mocks base method.
func (m *MockHumanUserRepository) SkipMultifactorInitializationAt(skippedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SkipMultifactorInitializationAt", skippedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SkipMultifactorInitializationAt indicates an expected call of SkipMultifactorInitializationAt.
func (mr *MockHumanUserRepositoryMockRecorder) SkipMultifactorInitializationAt(skippedAt any) *MockHumanUserRepositorySkipMultifactorInitializationAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SkipMultifactorInitializationAt", reflect.TypeOf((*MockHumanUserRepository)(nil).SkipMultifactorInitializationAt), skippedAt)
	return &MockHumanUserRepositorySkipMultifactorInitializationAtCall{Call: call}
}

// MockHumanUserRepositorySkipMultifactorInitializationAtCall wrap *gomock.Call
type MockHumanUserRepositorySkipMultifactorInitializationAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositorySkipMultifactorInitializationAtCall) Return(arg0 database.Change) *MockHumanUserRepositorySkipMultifactorInitializationAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositorySkipMultifactorInitializationAtCall) Do(f func(time.Time) database.Change) *MockHumanUserRepositorySkipMultifactorInitializationAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySkipMultifactorInitializationAtCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySkipMultifactorInitializationAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StateColumn mocks base method.
func (m *MockHumanUserRepository) StateColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// StateColumn indicates an expected call of StateColumn.
func (mr *MockHumanUserRepositoryMockRecorder) StateColumn() *MockHumanUserRepositoryStateColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).StateColumn))
	return &MockHumanUserRepositoryStateColumnCall{Call: call}
}

// MockHumanUserRepositoryStateColumnCall wrap *gomock.Call
type MockHumanUserRepositoryStateColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryStateColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryStateColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryStateColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryStateColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryStateColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StateCondition mocks base method.
func (m *MockHumanUserRepository) StateCondition(state domain.UserState) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateCondition", state)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// StateCondition indicates an expected call of StateCondition.
func (mr *MockHumanUserRepositoryMockRecorder) StateCondition(state any) *MockHumanUserRepositoryStateConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).StateCondition), state)
	return &MockHumanUserRepositoryStateConditionCall{Call: call}
}

// MockHumanUserRepositoryStateConditionCall wrap *gomock.Call
type MockHumanUserRepositoryStateConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryStateConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryStateConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryStateConditionCall) Do(f func(domain.UserState) database.Condition) *MockHumanUserRepositoryStateConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryStateConditionCall) DoAndReturn(f func(domain.UserState) database.Condition) *MockHumanUserRepositoryStateConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// TypeColumn mocks base method.
func (m *MockHumanUserRepository) TypeColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TypeColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// TypeColumn indicates an expected call of TypeColumn.
func (mr *MockHumanUserRepositoryMockRecorder) TypeColumn() *MockHumanUserRepositoryTypeColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).TypeColumn))
	return &MockHumanUserRepositoryTypeColumnCall{Call: call}
}

// MockHumanUserRepositoryTypeColumnCall wrap *gomock.Call
type MockHumanUserRepositoryTypeColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryTypeColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryTypeColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryTypeColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryTypeColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryTypeColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// TypeCondition mocks base method.
func (m *MockHumanUserRepository) TypeCondition(userType domain.UserType) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TypeCondition", userType)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// TypeCondition indicates an expected call of TypeCondition.
func (mr *MockHumanUserRepositoryMockRecorder) TypeCondition(userType any) *MockHumanUserRepositoryTypeConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).TypeCondition), userType)
	return &MockHumanUserRepositoryTypeConditionCall{Call: call}
}

// MockHumanUserRepositoryTypeConditionCall wrap *gomock.Call
type MockHumanUserRepositoryTypeConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryTypeConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryTypeConditionCall) Do(f func(domain.UserType) database.Condition) *MockHumanUserRepositoryTypeConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryTypeConditionCall) DoAndReturn(f func(domain.UserType) database.Condition) *MockHumanUserRepositoryTypeConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnverifiedEmailCondition mocks base method.
func (m *MockHumanUserRepository) UnverifiedEmailCondition(op database.TextOperation, email string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnverifiedEmailCondition", op, email)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// UnverifiedEmailCondition indicates an expected call of UnverifiedEmailCondition.
func (mr *MockHumanUserRepositoryMockRecorder) UnverifiedEmailCondition(op, email any) *MockHumanUserRepositoryUnverifiedEmailConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnverifiedEmailCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).UnverifiedEmailCondition), op, email)
	return &MockHumanUserRepositoryUnverifiedEmailConditionCall{Call: call}
}

// MockHumanUserRepositoryUnverifiedEmailConditionCall wrap *gomock.Call
type MockHumanUserRepositoryUnverifiedEmailConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryUnverifiedEmailConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryUnverifiedEmailConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryUnverifiedEmailConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryUnverifiedEmailConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryUnverifiedEmailConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryUnverifiedEmailConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnverifiedPhoneCondition mocks base method.
func (m *MockHumanUserRepository) UnverifiedPhoneCondition(op database.TextOperation, phone string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnverifiedPhoneCondition", op, phone)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// UnverifiedPhoneCondition indicates an expected call of UnverifiedPhoneCondition.
func (mr *MockHumanUserRepositoryMockRecorder) UnverifiedPhoneCondition(op, phone any) *MockHumanUserRepositoryUnverifiedPhoneConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnverifiedPhoneCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).UnverifiedPhoneCondition), op, phone)
	return &MockHumanUserRepositoryUnverifiedPhoneConditionCall{Call: call}
}

// MockHumanUserRepositoryUnverifiedPhoneConditionCall wrap *gomock.Call
type MockHumanUserRepositoryUnverifiedPhoneConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryUnverifiedPhoneConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryUnverifiedPhoneConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryUnverifiedPhoneConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryUnverifiedPhoneConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryUnverifiedPhoneConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryUnverifiedPhoneConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Update mocks base method.
func (m *MockHumanUserRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client, condition}
	for _, a := range changes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockHumanUserRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockHumanUserRepositoryUpdateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, condition}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockHumanUserRepository)(nil).Update), varargs...)
	return &MockHumanUserRepositoryUpdateCall{Call: call}
}

// MockHumanUserRepositoryUpdateCall wrap *gomock.Call
type MockHumanUserRepositoryUpdateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryUpdateCall) Return(arg0 int64, arg1 error) *MockHumanUserRepositoryUpdateCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryUpdateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockHumanUserRepositoryUpdateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryUpdateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockHumanUserRepositoryUpdateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdateIdentityProviderLink mocks base method.
func (m *MockHumanUserRepository) UpdateIdentityProviderLink(condition database.Condition, changes ...database.Change) database.Change {
	m.ctrl.T.Helper()
	varargs := []any{condition}
	for _, a := range changes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateIdentityProviderLink", varargs...)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// UpdateIdentityProviderLink indicates an expected call of UpdateIdentityProviderLink.
func (mr *MockHumanUserRepositoryMockRecorder) UpdateIdentityProviderLink(condition any, changes ...any) *MockHumanUserRepositoryUpdateIdentityProviderLinkCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{condition}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIdentityProviderLink", reflect.TypeOf((*MockHumanUserRepository)(nil).UpdateIdentityProviderLink), varargs...)
	return &MockHumanUserRepositoryUpdateIdentityProviderLinkCall{Call: call}
}

// MockHumanUserRepositoryUpdateIdentityProviderLinkCall wrap *gomock.Call
type MockHumanUserRepositoryUpdateIdentityProviderLinkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryUpdateIdentityProviderLinkCall) Return(arg0 database.Change) *MockHumanUserRepositoryUpdateIdentityProviderLinkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryUpdateIdentityProviderLinkCall) Do(f func(database.Condition, ...database.Change) database.Change) *MockHumanUserRepositoryUpdateIdentityProviderLinkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryUpdateIdentityProviderLinkCall) DoAndReturn(f func(database.Condition, ...database.Change) database.Change) *MockHumanUserRepositoryUpdateIdentityProviderLinkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatePasskey mocks base method.
func (m *MockHumanUserRepository) UpdatePasskey(condition database.Condition, changes ...database.Change) database.Change {
	m.ctrl.T.Helper()
	varargs := []any{condition}
	for _, a := range changes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePasskey", varargs...)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// UpdatePasskey indicates an expected call of UpdatePasskey.
func (mr *MockHumanUserRepositoryMockRecorder) UpdatePasskey(condition any, changes ...any) *MockHumanUserRepositoryUpdatePasskeyCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{condition}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePasskey", reflect.TypeOf((*MockHumanUserRepository)(nil).UpdatePasskey), varargs...)
	return &MockHumanUserRepositoryUpdatePasskeyCall{Call: call}
}

// MockHumanUserRepositoryUpdatePasskeyCall wrap *gomock.Call
type MockHumanUserRepositoryUpdatePasskeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryUpdatePasskeyCall) Return(arg0 database.Change) *MockHumanUserRepositoryUpdatePasskeyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryUpdatePasskeyCall) Do(f func(database.Condition, ...database.Change) database.Change) *MockHumanUserRepositoryUpdatePasskeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryUpdatePasskeyCall) DoAndReturn(f func(database.Condition, ...database.Change) database.Change) *MockHumanUserRepositoryUpdatePasskeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UsernameColumn mocks base method.
func (m *MockHumanUserRepository) UsernameColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UsernameColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// UsernameColumn indicates an expected call of UsernameColumn.
func (mr *MockHumanUserRepositoryMockRecorder) UsernameColumn() *MockHumanUserRepositoryUsernameColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsernameColumn", reflect.TypeOf((*MockHumanUserRepository)(nil).UsernameColumn))
	return &MockHumanUserRepositoryUsernameColumnCall{Call: call}
}

// MockHumanUserRepositoryUsernameColumnCall wrap *gomock.Call
type MockHumanUserRepositoryUsernameColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryUsernameColumnCall) Return(arg0 database.Column) *MockHumanUserRepositoryUsernameColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryUsernameColumnCall) Do(f func() database.Column) *MockHumanUserRepositoryUsernameColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryUsernameColumnCall) DoAndReturn(f func() database.Column) *MockHumanUserRepositoryUsernameColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UsernameCondition mocks base method.
func (m *MockHumanUserRepository) UsernameCondition(op database.TextOperation, username string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UsernameCondition", op, username)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// UsernameCondition indicates an expected call of UsernameCondition.
func (mr *MockHumanUserRepositoryMockRecorder) UsernameCondition(op, username any) *MockHumanUserRepositoryUsernameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsernameCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).UsernameCondition), op, username)
	return &MockHumanUserRepositoryUsernameConditionCall{Call: call}
}

// MockHumanUserRepositoryUsernameConditionCall wrap *gomock.Call
type MockHumanUserRepositoryUsernameConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryUsernameConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryUsernameConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryUsernameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryUsernameConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryUsernameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryUsernameConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// VerifiedEmailCondition mocks base method.
func (m *MockHumanUserRepository) VerifiedEmailCondition(op database.TextOperation, email string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifiedEmailCondition", op, email)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// VerifiedEmailCondition indicates an expected call of VerifiedEmailCondition.
func (mr *MockHumanUserRepositoryMockRecorder) VerifiedEmailCondition(op, email any) *MockHumanUserRepositoryVerifiedEmailConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifiedEmailCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).VerifiedEmailCondition), op, email)
	return &MockHumanUserRepositoryVerifiedEmailConditionCall{Call: call}
}

// MockHumanUserRepositoryVerifiedEmailConditionCall wrap *gomock.Call
type MockHumanUserRepositoryVerifiedEmailConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryVerifiedEmailConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryVerifiedEmailConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryVerifiedEmailConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryVerifiedEmailConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryVerifiedEmailConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryVerifiedEmailConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// VerifiedPhoneCondition mocks base method.
func (m *MockHumanUserRepository) VerifiedPhoneCondition(op database.TextOperation, phone string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifiedPhoneCondition", op, phone)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// VerifiedPhoneCondition indicates an expected call of VerifiedPhoneCondition.
func (mr *MockHumanUserRepositoryMockRecorder) VerifiedPhoneCondition(op, phone any) *MockHumanUserRepositoryVerifiedPhoneConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifiedPhoneCondition", reflect.TypeOf((*MockHumanUserRepository)(nil).VerifiedPhoneCondition), op, phone)
	return &MockHumanUserRepositoryVerifiedPhoneConditionCall{Call: call}
}

// MockHumanUserRepositoryVerifiedPhoneConditionCall wrap *gomock.Call
type MockHumanUserRepositoryVerifiedPhoneConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockHumanUserRepositoryVerifiedPhoneConditionCall) Return(arg0 database.Condition) *MockHumanUserRepositoryVerifiedPhoneConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryVerifiedPhoneConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryVerifiedPhoneConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryVerifiedPhoneConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockHumanUserRepositoryVerifiedPhoneConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}