// 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"
	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
}

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryAddMetadataCall) DoAndReturn(f func(...*domain.Metadata) database.Change) *MockHumanUserRepositoryAddMetadataCall {
	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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryCheckTOTPCall) DoAndReturn(f func(domain.CheckType) database.Change) *MockHumanUserRepositoryCheckTOTPCall {
	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
}

// 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
}

// 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
}

// 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
}

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryIdentityProviderIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockHumanUserRepositoryIdentityProviderIDConditionCall {
	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
}

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

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

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockHumanUserRepositoryMetadataValueConditionCall) Do(f func(database.BytesOperation, []byte) database.Condition) *MockHumanUserRepositoryMetadataValueConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryMetadataValueConditionCall) DoAndReturn(f func(database.BytesOperation, []byte) database.Condition) *MockHumanUserRepositoryMetadataValueConditionCall {
	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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryPasskeyKeyIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockHumanUserRepositoryPasskeyKeyIDConditionCall {
	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
}

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

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

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryProvidedUsernameConditionCall) DoAndReturn(f func(string) database.Condition) *MockHumanUserRepositoryProvidedUsernameConditionCall {
	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
}

// 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
}

// 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(verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEmail", verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetEmail indicates an expected call of SetEmail.
func (mr *MockHumanUserRepositoryMockRecorder) SetEmail(verification any) *MockHumanUserRepositorySetEmailCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEmail", reflect.TypeOf((*MockHumanUserRepository)(nil).SetEmail), verification)
	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(domain.VerificationType) database.Change) *MockHumanUserRepositorySetEmailCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetEmailCall) DoAndReturn(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetEmailCall {
	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(providerID, currentProvidedUserID, newProvidedUserID string) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIdentityProviderLinkProvidedID", providerID, currentProvidedUserID, newProvidedUserID)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetIdentityProviderLinkProvidedID indicates an expected call of SetIdentityProviderLinkProvidedID.
func (mr *MockHumanUserRepositoryMockRecorder) SetIdentityProviderLinkProvidedID(providerID, currentProvidedUserID, newProvidedUserID any) *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIdentityProviderLinkProvidedID", reflect.TypeOf((*MockHumanUserRepository)(nil).SetIdentityProviderLinkProvidedID), providerID, currentProvidedUserID, newProvidedUserID)
	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, string, string) database.Change) *MockHumanUserRepositorySetIdentityProviderLinkProvidedIDCall {
	c.Call = c.Call.Do(f)
	return c
}

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

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

// SetIdentityProviderLinkUsername indicates an expected call of SetIdentityProviderLinkUsername.
func (mr *MockHumanUserRepositoryMockRecorder) SetIdentityProviderLinkUsername(providerID, providedUserID, username any) *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIdentityProviderLinkUsername", reflect.TypeOf((*MockHumanUserRepository)(nil).SetIdentityProviderLinkUsername), providerID, providedUserID, 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, string, string) database.Change) *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall) DoAndReturn(f func(string, string, string) database.Change) *MockHumanUserRepositorySetIdentityProviderLinkUsernameCall {
	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
}

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetMultifactorInitializationSkippedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockHumanUserRepositorySetMultifactorInitializationSkippedAtCall {
	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(verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPassword", verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPassword indicates an expected call of SetPassword.
func (mr *MockHumanUserRepositoryMockRecorder) SetPassword(verification any) *MockHumanUserRepositorySetPasswordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPassword", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPassword), verification)
	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(domain.VerificationType) database.Change) *MockHumanUserRepositorySetPasswordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPasswordCall) DoAndReturn(f func(domain.VerificationType) 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(verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPhone", verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetPhone indicates an expected call of SetPhone.
func (mr *MockHumanUserRepositoryMockRecorder) SetPhone(verification any) *MockHumanUserRepositorySetPhoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPhone", reflect.TypeOf((*MockHumanUserRepository)(nil).SetPhone), verification)
	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(domain.VerificationType) database.Change) *MockHumanUserRepositorySetPhoneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetPhoneCall) DoAndReturn(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetPhoneCall {
	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
}

// 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
}

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetTOTPCall) DoAndReturn(f func(domain.VerificationType) database.Change) *MockHumanUserRepositorySetTOTPCall {
	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(id string, verification domain.VerificationType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVerification", id, verification)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetVerification indicates an expected call of SetVerification.
func (mr *MockHumanUserRepositoryMockRecorder) SetVerification(id, verification any) *MockHumanUserRepositorySetVerificationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVerification", reflect.TypeOf((*MockHumanUserRepository)(nil).SetVerification), id, 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(string, domain.VerificationType) database.Change) *MockHumanUserRepositorySetVerificationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositorySetVerificationCall) DoAndReturn(f func(string, domain.VerificationType) database.Change) *MockHumanUserRepositorySetVerificationCall {
	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
}

// 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
}

// 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(changes ...database.Change) database.Change {
	m.ctrl.T.Helper()
	varargs := []any{}
	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(changes ...any) *MockHumanUserRepositoryUpdateIdentityProviderLinkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIdentityProviderLink", reflect.TypeOf((*MockHumanUserRepository)(nil).UpdateIdentityProviderLink), changes...)
	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.Change) database.Change) *MockHumanUserRepositoryUpdateIdentityProviderLinkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockHumanUserRepositoryUpdateIdentityProviderLinkCall) DoAndReturn(f func(...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
}