From f5ce288ea55adf8cab6e468325a6f117aca96222 Mon Sep 17 00:00:00 2001 From: Silvan <27845747+adlerhurst@users.noreply.github.com> Date: Tue, 25 Nov 2025 11:54:32 +0100 Subject: [PATCH] feat(domain): define user repositories (#11059) This pull request introduces a new set of domain models and repositories for managing users within the new v3 structure. The goal is to establish a clean, robust, and extensible foundation for user management. ### Summary This PR accomplishes the following: - **Polymorphic User Model**: Introduces a `User` model in user.go that can represent either a `Human` or a `Machine` user. This provides a unified way to handle different user types while allowing for specific attributes and logic for each. - **Repository Pattern**: Implements the repository pattern for accessing and manipulating user data. This decouples the business logic from the data storage implementation. The main repository interfaces (`UserRepository`, `HumanUserRepository`, `MachineUserRepository`) are now defined in `backend/v3/domain/user_repository.go`. - **Comprehensive User Models**: The user.go file now also defines the domain models for associated user data, including `UserMetadata`, `IdentityProviderLink`, `Passkey`, `PersonalAccessToken`, and `MachineKey`. - **Generic Verification and Check System**: Introduces verification.go and check.go to provide a standardized way of handling various verification flows (e.g., email verification, OTP checks). - **Generated Code**: Adds new generated files for enums (`humangender_enumer.go`, `machinekeytype_enumer.go`, `passkeytype_enumer.go`, `personalaccesstokentype_enumer.go`, `userstate_enumer.go`, `usertype_enumer.go`) and mocks for the new repositories. - **Session Domain Refactoring**: Updates the session domain (`backend/v3/domain/session*.go`) to align with the new user model structure. This foundational work paves the way for migrating user management logic to the new `v3` backend, with a more maintainable and testable architecture. part of #10224 --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Marco A. --- backend/v3/domain/check.go | 67 + backend/v3/domain/humangender_enumer.go | 86 + backend/v3/domain/machinekeytype_enumer.go | 82 + backend/v3/domain/mock/human_user.mock.go | 3104 +++++++++++++++++ backend/v3/domain/mock/instance.mock.go | 119 +- .../v3/domain/mock/instance_domain.mock.go | 95 +- backend/v3/domain/mock/machine_user.mock.go | 1156 ++++++ backend/v3/domain/mock/permission.mock.go | 33 +- backend/v3/domain/mock/session.mock.go | 1392 ++++++++ backend/v3/domain/mock/user.mock.go | 1321 +++++++ backend/v3/domain/passkeytype_enumer.go | 82 + .../domain/personalaccesstokentype_enumer.go | 82 + backend/v3/domain/session.go | 12 +- backend/v3/domain/session_factor.go | 4 +- backend/v3/domain/session_metadata.go | 4 +- backend/v3/domain/session_user_agent.go | 4 +- backend/v3/domain/user.go | 422 ++- backend/v3/domain/user_repo.go | 314 ++ backend/v3/domain/userstate_enumer.go | 121 + backend/v3/domain/usertype_enumer.go | 82 + backend/v3/domain/verification.go | 79 + .../v3/storage/database/operators_enumer.go | 16 +- .../v3/storage/database/repository/user.go | 291 -- .../storage/database/repository/user_human.go | 208 -- .../database/repository/user_machine.go | 67 - 25 files changed, 8317 insertions(+), 926 deletions(-) create mode 100644 backend/v3/domain/check.go create mode 100644 backend/v3/domain/humangender_enumer.go create mode 100644 backend/v3/domain/machinekeytype_enumer.go create mode 100644 backend/v3/domain/mock/human_user.mock.go create mode 100644 backend/v3/domain/mock/machine_user.mock.go create mode 100644 backend/v3/domain/mock/session.mock.go create mode 100644 backend/v3/domain/mock/user.mock.go create mode 100644 backend/v3/domain/passkeytype_enumer.go create mode 100644 backend/v3/domain/personalaccesstokentype_enumer.go create mode 100644 backend/v3/domain/user_repo.go create mode 100644 backend/v3/domain/userstate_enumer.go create mode 100644 backend/v3/domain/usertype_enumer.go create mode 100644 backend/v3/domain/verification.go delete mode 100644 backend/v3/storage/database/repository/user.go delete mode 100644 backend/v3/storage/database/repository/user_human.go delete mode 100644 backend/v3/storage/database/repository/user_machine.go diff --git a/backend/v3/domain/check.go b/backend/v3/domain/check.go new file mode 100644 index 000000000..7212fa58f --- /dev/null +++ b/backend/v3/domain/check.go @@ -0,0 +1,67 @@ +package domain + +import "time" + +type Check struct { + Code []byte `db:"code"` + ExpiresAt *time.Time `db:"expires_at"` + FailedAttempts uint8 `db:"failed_attempts"` +} + +type CheckType interface { + isCheckType() +} + +type PasswordCheckType interface { + isPasswordCheckType() +} + +// CheckTypeInit initializes a new check. +type CheckTypeInit struct { + // CreatedAt is the time when the check was created. + // If zero, the current time will be used. + CreatedAt time.Time + // Expiry is the duration after which the check expires. + Expiry *time.Duration + // Code to be used for the check. + Code []byte +} + +// isCheckType implements [CheckType]. +func (v *CheckTypeInit) isCheckType() {} + +var _ CheckType = (*CheckTypeInit)(nil) + +// CheckTypeFailed indicates that the check failed. +// It is used to increment the failed attempts counter. +type CheckTypeFailed struct { + FailedAt time.Time +} + +// isCheckType implements [CheckType]. +func (v *CheckTypeFailed) isCheckType() {} + +// isPasswordCheckType implements [PasswordCheckType]. +func (v *CheckTypeFailed) isPasswordCheckType() {} + +var ( + _ CheckType = (*CheckTypeFailed)(nil) + _ PasswordCheckType = (*CheckTypeFailed)(nil) +) + +// CheckTypeSucceeded indicates that the check succeeded. +// It is used to reset the failed attempts counter. +type CheckTypeSucceeded struct { + SucceededAt time.Time +} + +// isCheckType implements [CheckType]. +func (v *CheckTypeSucceeded) isCheckType() {} + +// isPasswordCheckType implements [PasswordCheckType]. +func (v *CheckTypeSucceeded) isPasswordCheckType() {} + +var ( + _ CheckType = (*CheckTypeSucceeded)(nil) + _ PasswordCheckType = (*CheckTypeSucceeded)(nil) +) diff --git a/backend/v3/domain/humangender_enumer.go b/backend/v3/domain/humangender_enumer.go new file mode 100644 index 000000000..1b881a58f --- /dev/null +++ b/backend/v3/domain/humangender_enumer.go @@ -0,0 +1,86 @@ +// Code generated by "enumer -type HumanGender -transform lower -trimprefix HumanGender"; DO NOT EDIT. + +package domain + +import ( + "fmt" + "strings" +) + +const _HumanGenderName = "unspecifiedfemalemalediverse" + +var _HumanGenderIndex = [...]uint8{0, 11, 17, 21, 28} + +const _HumanGenderLowerName = "unspecifiedfemalemalediverse" + +func (i HumanGender) String() string { + if i >= HumanGender(len(_HumanGenderIndex)-1) { + return fmt.Sprintf("HumanGender(%d)", i) + } + return _HumanGenderName[_HumanGenderIndex[i]:_HumanGenderIndex[i+1]] +} + +// An "invalid array index" compiler error signifies that the constant values have changed. +// Re-run the stringer command to generate them again. +func _HumanGenderNoOp() { + var x [1]struct{} + _ = x[HumanGenderUnspecified-(0)] + _ = x[HumanGenderFemale-(1)] + _ = x[HumanGenderMale-(2)] + _ = x[HumanGenderDiverse-(3)] +} + +var _HumanGenderValues = []HumanGender{HumanGenderUnspecified, HumanGenderFemale, HumanGenderMale, HumanGenderDiverse} + +var _HumanGenderNameToValueMap = map[string]HumanGender{ + _HumanGenderName[0:11]: HumanGenderUnspecified, + _HumanGenderLowerName[0:11]: HumanGenderUnspecified, + _HumanGenderName[11:17]: HumanGenderFemale, + _HumanGenderLowerName[11:17]: HumanGenderFemale, + _HumanGenderName[17:21]: HumanGenderMale, + _HumanGenderLowerName[17:21]: HumanGenderMale, + _HumanGenderName[21:28]: HumanGenderDiverse, + _HumanGenderLowerName[21:28]: HumanGenderDiverse, +} + +var _HumanGenderNames = []string{ + _HumanGenderName[0:11], + _HumanGenderName[11:17], + _HumanGenderName[17:21], + _HumanGenderName[21:28], +} + +// HumanGenderString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func HumanGenderString(s string) (HumanGender, error) { + if val, ok := _HumanGenderNameToValueMap[s]; ok { + return val, nil + } + + if val, ok := _HumanGenderNameToValueMap[strings.ToLower(s)]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to HumanGender values", s) +} + +// HumanGenderValues returns all values of the enum +func HumanGenderValues() []HumanGender { + return _HumanGenderValues +} + +// HumanGenderStrings returns a slice of all String values of the enum +func HumanGenderStrings() []string { + strs := make([]string, len(_HumanGenderNames)) + copy(strs, _HumanGenderNames) + return strs +} + +// IsAHumanGender returns "true" if the value is listed in the enum definition. "false" otherwise +func (i HumanGender) IsAHumanGender() bool { + for _, v := range _HumanGenderValues { + if i == v { + return true + } + } + return false +} diff --git a/backend/v3/domain/machinekeytype_enumer.go b/backend/v3/domain/machinekeytype_enumer.go new file mode 100644 index 000000000..aa423cdcf --- /dev/null +++ b/backend/v3/domain/machinekeytype_enumer.go @@ -0,0 +1,82 @@ +// Code generated by "enumer -type MachineKeyType -transform lower -trimprefix MachineKeyType"; DO NOT EDIT. + +package domain + +import ( + "fmt" + "strings" +) + +const _MachineKeyTypeName = "unspecifiedjsonnone" + +var _MachineKeyTypeIndex = [...]uint8{0, 11, 15, 19} + +const _MachineKeyTypeLowerName = "unspecifiedjsonnone" + +func (i MachineKeyType) String() string { + if i >= MachineKeyType(len(_MachineKeyTypeIndex)-1) { + return fmt.Sprintf("MachineKeyType(%d)", i) + } + return _MachineKeyTypeName[_MachineKeyTypeIndex[i]:_MachineKeyTypeIndex[i+1]] +} + +// An "invalid array index" compiler error signifies that the constant values have changed. +// Re-run the stringer command to generate them again. +func _MachineKeyTypeNoOp() { + var x [1]struct{} + _ = x[MachineKeyTypeUnspecified-(0)] + _ = x[MachineKeyTypeJSON-(1)] + _ = x[MachineKeyTypeNone-(2)] +} + +var _MachineKeyTypeValues = []MachineKeyType{MachineKeyTypeUnspecified, MachineKeyTypeJSON, MachineKeyTypeNone} + +var _MachineKeyTypeNameToValueMap = map[string]MachineKeyType{ + _MachineKeyTypeName[0:11]: MachineKeyTypeUnspecified, + _MachineKeyTypeLowerName[0:11]: MachineKeyTypeUnspecified, + _MachineKeyTypeName[11:15]: MachineKeyTypeJSON, + _MachineKeyTypeLowerName[11:15]: MachineKeyTypeJSON, + _MachineKeyTypeName[15:19]: MachineKeyTypeNone, + _MachineKeyTypeLowerName[15:19]: MachineKeyTypeNone, +} + +var _MachineKeyTypeNames = []string{ + _MachineKeyTypeName[0:11], + _MachineKeyTypeName[11:15], + _MachineKeyTypeName[15:19], +} + +// MachineKeyTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func MachineKeyTypeString(s string) (MachineKeyType, error) { + if val, ok := _MachineKeyTypeNameToValueMap[s]; ok { + return val, nil + } + + if val, ok := _MachineKeyTypeNameToValueMap[strings.ToLower(s)]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to MachineKeyType values", s) +} + +// MachineKeyTypeValues returns all values of the enum +func MachineKeyTypeValues() []MachineKeyType { + return _MachineKeyTypeValues +} + +// MachineKeyTypeStrings returns a slice of all String values of the enum +func MachineKeyTypeStrings() []string { + strs := make([]string, len(_MachineKeyTypeNames)) + copy(strs, _MachineKeyTypeNames) + return strs +} + +// IsAMachineKeyType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i MachineKeyType) IsAMachineKeyType() bool { + for _, v := range _MachineKeyTypeValues { + if i == v { + return true + } + } + return false +} diff --git a/backend/v3/domain/mock/human_user.mock.go b/backend/v3/domain/mock/human_user.mock.go new file mode 100644 index 000000000..bb84ac124 --- /dev/null +++ b/backend/v3/domain/mock/human_user.mock.go @@ -0,0 +1,3104 @@ +// 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 +} diff --git a/backend/v3/domain/mock/instance.mock.go b/backend/v3/domain/mock/instance.mock.go index c178e0fef..30a29a04b 100644 --- a/backend/v3/domain/mock/instance.mock.go +++ b/backend/v3/domain/mock/instance.mock.go @@ -24,6 +24,7 @@ import ( type MockInstanceRepository struct { ctrl *gomock.Controller recorder *MockInstanceRepositoryMockRecorder + isgomock struct{} } // MockInstanceRepositoryMockRecorder is the mock recorder for MockInstanceRepository. @@ -120,17 +121,17 @@ func (c *MockInstanceRepositoryConsoleClientIDColumnCall) DoAndReturn(f func() d } // Create mocks base method. -func (m *MockInstanceRepository) Create(arg0 context.Context, arg1 database.QueryExecutor, arg2 *domain.Instance) error { +func (m *MockInstanceRepository) Create(ctx context.Context, client database.QueryExecutor, instance *domain.Instance) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Create", ctx, client, instance) ret0, _ := ret[0].(error) return ret0 } // Create indicates an expected call of Create. -func (mr *MockInstanceRepositoryMockRecorder) Create(arg0, arg1, arg2 any) *MockInstanceRepositoryCreateCall { +func (mr *MockInstanceRepositoryMockRecorder) Create(ctx, client, instance any) *MockInstanceRepositoryCreateCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockInstanceRepository)(nil).Create), arg0, arg1, arg2) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockInstanceRepository)(nil).Create), ctx, client, instance) return &MockInstanceRepositoryCreateCall{Call: call} } @@ -272,18 +273,18 @@ func (c *MockInstanceRepositoryDefaultOrgIDColumnCall) DoAndReturn(f func() data } // Delete mocks base method. -func (m *MockInstanceRepository) Delete(arg0 context.Context, arg1 database.QueryExecutor, arg2 string) (int64, error) { +func (m *MockInstanceRepository) Delete(ctx context.Context, client database.QueryExecutor, id string) (int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Delete", ctx, client, id) ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) return ret0, ret1 } // Delete indicates an expected call of Delete. -func (mr *MockInstanceRepositoryMockRecorder) Delete(arg0, arg1, arg2 any) *MockInstanceRepositoryDeleteCall { +func (mr *MockInstanceRepositoryMockRecorder) Delete(ctx, client, id any) *MockInstanceRepositoryDeleteCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInstanceRepository)(nil).Delete), arg0, arg1, arg2) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInstanceRepository)(nil).Delete), ctx, client, id) return &MockInstanceRepositoryDeleteCall{Call: call} } @@ -311,17 +312,17 @@ func (c *MockInstanceRepositoryDeleteCall) DoAndReturn(f func(context.Context, d } // ExistsDomain mocks base method. -func (m *MockInstanceRepository) ExistsDomain(arg0 database.Condition) database.Condition { +func (m *MockInstanceRepository) ExistsDomain(cond database.Condition) database.Condition { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExistsDomain", arg0) + ret := m.ctrl.Call(m, "ExistsDomain", cond) ret0, _ := ret[0].(database.Condition) return ret0 } // ExistsDomain indicates an expected call of ExistsDomain. -func (mr *MockInstanceRepositoryMockRecorder) ExistsDomain(arg0 any) *MockInstanceRepositoryExistsDomainCall { +func (mr *MockInstanceRepositoryMockRecorder) ExistsDomain(cond any) *MockInstanceRepositoryExistsDomainCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsDomain", reflect.TypeOf((*MockInstanceRepository)(nil).ExistsDomain), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsDomain", reflect.TypeOf((*MockInstanceRepository)(nil).ExistsDomain), cond) return &MockInstanceRepositoryExistsDomainCall{Call: call} } @@ -349,10 +350,10 @@ func (c *MockInstanceRepositoryExistsDomainCall) DoAndReturn(f func(database.Con } // Get mocks base method. -func (m *MockInstanceRepository) Get(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...database.QueryOption) (*domain.Instance, error) { +func (m *MockInstanceRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.Instance, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, client} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Get", varargs...) @@ -362,9 +363,9 @@ func (m *MockInstanceRepository) Get(arg0 context.Context, arg1 database.QueryEx } // Get indicates an expected call of Get. -func (mr *MockInstanceRepositoryMockRecorder) Get(arg0, arg1 any, arg2 ...any) *MockInstanceRepositoryGetCall { +func (mr *MockInstanceRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockInstanceRepositoryGetCall { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, client}, opts...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInstanceRepository)(nil).Get), varargs...) return &MockInstanceRepositoryGetCall{Call: call} } @@ -469,17 +470,17 @@ func (c *MockInstanceRepositoryIDColumnCall) DoAndReturn(f func() database.Colum } // IDCondition mocks base method. -func (m *MockInstanceRepository) IDCondition(arg0 string) database.Condition { +func (m *MockInstanceRepository) IDCondition(instanceID string) database.Condition { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IDCondition", arg0) + ret := m.ctrl.Call(m, "IDCondition", instanceID) ret0, _ := ret[0].(database.Condition) return ret0 } // IDCondition indicates an expected call of IDCondition. -func (mr *MockInstanceRepositoryMockRecorder) IDCondition(arg0 any) *MockInstanceRepositoryIDConditionCall { +func (mr *MockInstanceRepositoryMockRecorder) IDCondition(instanceID any) *MockInstanceRepositoryIDConditionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockInstanceRepository)(nil).IDCondition), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockInstanceRepository)(nil).IDCondition), instanceID) return &MockInstanceRepositoryIDConditionCall{Call: call} } @@ -507,10 +508,10 @@ func (c *MockInstanceRepositoryIDConditionCall) DoAndReturn(f func(string) datab } // List mocks base method. -func (m *MockInstanceRepository) List(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...database.QueryOption) ([]*domain.Instance, error) { +func (m *MockInstanceRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.Instance, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, client} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "List", varargs...) @@ -520,9 +521,9 @@ func (m *MockInstanceRepository) List(arg0 context.Context, arg1 database.QueryE } // List indicates an expected call of List. -func (mr *MockInstanceRepositoryMockRecorder) List(arg0, arg1 any, arg2 ...any) *MockInstanceRepositoryListCall { +func (mr *MockInstanceRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockInstanceRepositoryListCall { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, client}, opts...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInstanceRepository)(nil).List), varargs...) return &MockInstanceRepositoryListCall{Call: call} } @@ -627,17 +628,17 @@ func (c *MockInstanceRepositoryNameColumnCall) DoAndReturn(f func() database.Col } // NameCondition mocks base method. -func (m *MockInstanceRepository) NameCondition(arg0 database.TextOperation, arg1 string) database.Condition { +func (m *MockInstanceRepository) NameCondition(op database.TextOperation, name string) database.Condition { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NameCondition", arg0, arg1) + ret := m.ctrl.Call(m, "NameCondition", op, name) ret0, _ := ret[0].(database.Condition) return ret0 } // NameCondition indicates an expected call of NameCondition. -func (mr *MockInstanceRepositoryMockRecorder) NameCondition(arg0, arg1 any) *MockInstanceRepositoryNameConditionCall { +func (mr *MockInstanceRepositoryMockRecorder) NameCondition(op, name any) *MockInstanceRepositoryNameConditionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NameCondition", reflect.TypeOf((*MockInstanceRepository)(nil).NameCondition), arg0, arg1) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NameCondition", reflect.TypeOf((*MockInstanceRepository)(nil).NameCondition), op, name) return &MockInstanceRepositoryNameConditionCall{Call: call} } @@ -703,17 +704,17 @@ func (c *MockInstanceRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []dat } // PrimaryKeyCondition mocks base method. -func (m *MockInstanceRepository) PrimaryKeyCondition(arg0 string) database.Condition { +func (m *MockInstanceRepository) PrimaryKeyCondition(instanceID string) database.Condition { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PrimaryKeyCondition", arg0) + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID) ret0, _ := ret[0].(database.Condition) return ret0 } // PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. -func (mr *MockInstanceRepositoryMockRecorder) PrimaryKeyCondition(arg0 any) *MockInstanceRepositoryPrimaryKeyConditionCall { +func (mr *MockInstanceRepositoryMockRecorder) PrimaryKeyCondition(instanceID any) *MockInstanceRepositoryPrimaryKeyConditionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockInstanceRepository)(nil).PrimaryKeyCondition), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockInstanceRepository)(nil).PrimaryKeyCondition), instanceID) return &MockInstanceRepositoryPrimaryKeyConditionCall{Call: call} } @@ -741,17 +742,17 @@ func (c *MockInstanceRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(strin } // SetConsoleAppID mocks base method. -func (m *MockInstanceRepository) SetConsoleAppID(arg0 string) database.Change { +func (m *MockInstanceRepository) SetConsoleAppID(id string) database.Change { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetConsoleAppID", arg0) + ret := m.ctrl.Call(m, "SetConsoleAppID", id) ret0, _ := ret[0].(database.Change) return ret0 } // SetConsoleAppID indicates an expected call of SetConsoleAppID. -func (mr *MockInstanceRepositoryMockRecorder) SetConsoleAppID(arg0 any) *MockInstanceRepositorySetConsoleAppIDCall { +func (mr *MockInstanceRepositoryMockRecorder) SetConsoleAppID(id any) *MockInstanceRepositorySetConsoleAppIDCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConsoleAppID", reflect.TypeOf((*MockInstanceRepository)(nil).SetConsoleAppID), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConsoleAppID", reflect.TypeOf((*MockInstanceRepository)(nil).SetConsoleAppID), id) return &MockInstanceRepositorySetConsoleAppIDCall{Call: call} } @@ -779,17 +780,17 @@ func (c *MockInstanceRepositorySetConsoleAppIDCall) DoAndReturn(f func(string) d } // SetConsoleClientID mocks base method. -func (m *MockInstanceRepository) SetConsoleClientID(arg0 string) database.Change { +func (m *MockInstanceRepository) SetConsoleClientID(id string) database.Change { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetConsoleClientID", arg0) + ret := m.ctrl.Call(m, "SetConsoleClientID", id) ret0, _ := ret[0].(database.Change) return ret0 } // SetConsoleClientID indicates an expected call of SetConsoleClientID. -func (mr *MockInstanceRepositoryMockRecorder) SetConsoleClientID(arg0 any) *MockInstanceRepositorySetConsoleClientIDCall { +func (mr *MockInstanceRepositoryMockRecorder) SetConsoleClientID(id any) *MockInstanceRepositorySetConsoleClientIDCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConsoleClientID", reflect.TypeOf((*MockInstanceRepository)(nil).SetConsoleClientID), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConsoleClientID", reflect.TypeOf((*MockInstanceRepository)(nil).SetConsoleClientID), id) return &MockInstanceRepositorySetConsoleClientIDCall{Call: call} } @@ -855,17 +856,17 @@ func (c *MockInstanceRepositorySetDefaultLanguageCall) DoAndReturn(f func(langua } // SetDefaultOrg mocks base method. -func (m *MockInstanceRepository) SetDefaultOrg(arg0 string) database.Change { +func (m *MockInstanceRepository) SetDefaultOrg(id string) database.Change { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetDefaultOrg", arg0) + ret := m.ctrl.Call(m, "SetDefaultOrg", id) ret0, _ := ret[0].(database.Change) return ret0 } // SetDefaultOrg indicates an expected call of SetDefaultOrg. -func (mr *MockInstanceRepositoryMockRecorder) SetDefaultOrg(arg0 any) *MockInstanceRepositorySetDefaultOrgCall { +func (mr *MockInstanceRepositoryMockRecorder) SetDefaultOrg(id any) *MockInstanceRepositorySetDefaultOrgCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultOrg", reflect.TypeOf((*MockInstanceRepository)(nil).SetDefaultOrg), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultOrg", reflect.TypeOf((*MockInstanceRepository)(nil).SetDefaultOrg), id) return &MockInstanceRepositorySetDefaultOrgCall{Call: call} } @@ -893,17 +894,17 @@ func (c *MockInstanceRepositorySetDefaultOrgCall) DoAndReturn(f func(string) dat } // SetIAMProject mocks base method. -func (m *MockInstanceRepository) SetIAMProject(arg0 string) database.Change { +func (m *MockInstanceRepository) SetIAMProject(id string) database.Change { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetIAMProject", arg0) + ret := m.ctrl.Call(m, "SetIAMProject", id) ret0, _ := ret[0].(database.Change) return ret0 } // SetIAMProject indicates an expected call of SetIAMProject. -func (mr *MockInstanceRepositoryMockRecorder) SetIAMProject(arg0 any) *MockInstanceRepositorySetIAMProjectCall { +func (mr *MockInstanceRepositoryMockRecorder) SetIAMProject(id any) *MockInstanceRepositorySetIAMProjectCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIAMProject", reflect.TypeOf((*MockInstanceRepository)(nil).SetIAMProject), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIAMProject", reflect.TypeOf((*MockInstanceRepository)(nil).SetIAMProject), id) return &MockInstanceRepositorySetIAMProjectCall{Call: call} } @@ -931,17 +932,17 @@ func (c *MockInstanceRepositorySetIAMProjectCall) DoAndReturn(f func(string) dat } // SetName mocks base method. -func (m *MockInstanceRepository) SetName(arg0 string) database.Change { +func (m *MockInstanceRepository) SetName(name string) database.Change { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetName", arg0) + ret := m.ctrl.Call(m, "SetName", name) ret0, _ := ret[0].(database.Change) return ret0 } // SetName indicates an expected call of SetName. -func (mr *MockInstanceRepositoryMockRecorder) SetName(arg0 any) *MockInstanceRepositorySetNameCall { +func (mr *MockInstanceRepositoryMockRecorder) SetName(name any) *MockInstanceRepositorySetNameCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetName", reflect.TypeOf((*MockInstanceRepository)(nil).SetName), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetName", reflect.TypeOf((*MockInstanceRepository)(nil).SetName), name) return &MockInstanceRepositorySetNameCall{Call: call} } @@ -1007,10 +1008,10 @@ func (c *MockInstanceRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) d } // Update mocks base method. -func (m *MockInstanceRepository) Update(arg0 context.Context, arg1 database.QueryExecutor, arg2 string, arg3 ...database.Change) (int64, error) { +func (m *MockInstanceRepository) Update(ctx context.Context, client database.QueryExecutor, id string, changes ...database.Change) (int64, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1, arg2} - for _, a := range arg3 { + varargs := []any{ctx, client, id} + for _, a := range changes { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Update", varargs...) @@ -1020,9 +1021,9 @@ func (m *MockInstanceRepository) Update(arg0 context.Context, arg1 database.Quer } // Update indicates an expected call of Update. -func (mr *MockInstanceRepositoryMockRecorder) Update(arg0, arg1, arg2 any, arg3 ...any) *MockInstanceRepositoryUpdateCall { +func (mr *MockInstanceRepositoryMockRecorder) Update(ctx, client, id any, changes ...any) *MockInstanceRepositoryUpdateCall { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1, arg2}, arg3...) + varargs := append([]any{ctx, client, id}, changes...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInstanceRepository)(nil).Update), varargs...) return &MockInstanceRepositoryUpdateCall{Call: call} } diff --git a/backend/v3/domain/mock/instance_domain.mock.go b/backend/v3/domain/mock/instance_domain.mock.go index cea899f7d..2c296688f 100644 --- a/backend/v3/domain/mock/instance_domain.mock.go +++ b/backend/v3/domain/mock/instance_domain.mock.go @@ -23,6 +23,7 @@ import ( type MockInstanceDomainRepository struct { ctrl *gomock.Controller recorder *MockInstanceDomainRepositoryMockRecorder + isgomock struct{} } // MockInstanceDomainRepositoryMockRecorder is the mock recorder for MockInstanceDomainRepository. @@ -43,17 +44,17 @@ func (m *MockInstanceDomainRepository) EXPECT() *MockInstanceDomainRepositoryMoc } // Add mocks base method. -func (m *MockInstanceDomainRepository) Add(arg0 context.Context, arg1 database.QueryExecutor, arg2 *domain.AddInstanceDomain) error { +func (m *MockInstanceDomainRepository) Add(ctx context.Context, client database.QueryExecutor, arg2 *domain.AddInstanceDomain) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Add", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Add", ctx, client, arg2) ret0, _ := ret[0].(error) return ret0 } // Add indicates an expected call of Add. -func (mr *MockInstanceDomainRepositoryMockRecorder) Add(arg0, arg1, arg2 any) *MockInstanceDomainRepositoryAddCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) Add(ctx, client, arg2 any) *MockInstanceDomainRepositoryAddCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockInstanceDomainRepository)(nil).Add), arg0, arg1, arg2) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockInstanceDomainRepository)(nil).Add), ctx, client, arg2) return &MockInstanceDomainRepositoryAddCall{Call: call} } @@ -157,17 +158,17 @@ func (c *MockInstanceDomainRepositoryDomainColumnCall) DoAndReturn(f func() data } // DomainCondition mocks base method. -func (m *MockInstanceDomainRepository) DomainCondition(arg0 database.TextOperation, arg1 string) database.Condition { +func (m *MockInstanceDomainRepository) DomainCondition(op database.TextOperation, arg1 string) database.Condition { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DomainCondition", arg0, arg1) + ret := m.ctrl.Call(m, "DomainCondition", op, arg1) ret0, _ := ret[0].(database.Condition) return ret0 } // DomainCondition indicates an expected call of DomainCondition. -func (mr *MockInstanceDomainRepositoryMockRecorder) DomainCondition(arg0, arg1 any) *MockInstanceDomainRepositoryDomainConditionCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) DomainCondition(op, arg1 any) *MockInstanceDomainRepositoryDomainConditionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).DomainCondition), arg0, arg1) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).DomainCondition), op, arg1) return &MockInstanceDomainRepositoryDomainConditionCall{Call: call} } @@ -195,10 +196,10 @@ func (c *MockInstanceDomainRepositoryDomainConditionCall) DoAndReturn(f func(dat } // Get mocks base method. -func (m *MockInstanceDomainRepository) Get(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...database.QueryOption) (*domain.InstanceDomain, error) { +func (m *MockInstanceDomainRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.InstanceDomain, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, client} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Get", varargs...) @@ -208,9 +209,9 @@ func (m *MockInstanceDomainRepository) Get(arg0 context.Context, arg1 database.Q } // Get indicates an expected call of Get. -func (mr *MockInstanceDomainRepositoryMockRecorder) Get(arg0, arg1 any, arg2 ...any) *MockInstanceDomainRepositoryGetCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockInstanceDomainRepositoryGetCall { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, client}, opts...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInstanceDomainRepository)(nil).Get), varargs...) return &MockInstanceDomainRepositoryGetCall{Call: call} } @@ -277,17 +278,17 @@ func (c *MockInstanceDomainRepositoryInstanceIDColumnCall) DoAndReturn(f func() } // InstanceIDCondition mocks base method. -func (m *MockInstanceDomainRepository) InstanceIDCondition(arg0 string) database.Condition { +func (m *MockInstanceDomainRepository) InstanceIDCondition(instanceID string) database.Condition { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "InstanceIDCondition", arg0) + ret := m.ctrl.Call(m, "InstanceIDCondition", instanceID) ret0, _ := ret[0].(database.Condition) return ret0 } // InstanceIDCondition indicates an expected call of InstanceIDCondition. -func (mr *MockInstanceDomainRepositoryMockRecorder) InstanceIDCondition(arg0 any) *MockInstanceDomainRepositoryInstanceIDConditionCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockInstanceDomainRepositoryInstanceIDConditionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).InstanceIDCondition), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).InstanceIDCondition), instanceID) return &MockInstanceDomainRepositoryInstanceIDConditionCall{Call: call} } @@ -391,17 +392,17 @@ func (c *MockInstanceDomainRepositoryIsPrimaryColumnCall) DoAndReturn(f func() d } // IsPrimaryCondition mocks base method. -func (m *MockInstanceDomainRepository) IsPrimaryCondition(arg0 bool) database.Condition { +func (m *MockInstanceDomainRepository) IsPrimaryCondition(isPrimary bool) database.Condition { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsPrimaryCondition", arg0) + ret := m.ctrl.Call(m, "IsPrimaryCondition", isPrimary) ret0, _ := ret[0].(database.Condition) return ret0 } // IsPrimaryCondition indicates an expected call of IsPrimaryCondition. -func (mr *MockInstanceDomainRepositoryMockRecorder) IsPrimaryCondition(arg0 any) *MockInstanceDomainRepositoryIsPrimaryConditionCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) IsPrimaryCondition(isPrimary any) *MockInstanceDomainRepositoryIsPrimaryConditionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPrimaryCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).IsPrimaryCondition), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPrimaryCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).IsPrimaryCondition), isPrimary) return &MockInstanceDomainRepositoryIsPrimaryConditionCall{Call: call} } @@ -429,10 +430,10 @@ func (c *MockInstanceDomainRepositoryIsPrimaryConditionCall) DoAndReturn(f func( } // List mocks base method. -func (m *MockInstanceDomainRepository) List(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...database.QueryOption) ([]*domain.InstanceDomain, error) { +func (m *MockInstanceDomainRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.InstanceDomain, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, client} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "List", varargs...) @@ -442,9 +443,9 @@ func (m *MockInstanceDomainRepository) List(arg0 context.Context, arg1 database. } // List indicates an expected call of List. -func (mr *MockInstanceDomainRepositoryMockRecorder) List(arg0, arg1 any, arg2 ...any) *MockInstanceDomainRepositoryListCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockInstanceDomainRepositoryListCall { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, client}, opts...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockInstanceDomainRepository)(nil).List), varargs...) return &MockInstanceDomainRepositoryListCall{Call: call} } @@ -549,18 +550,18 @@ func (c *MockInstanceDomainRepositoryPrimaryKeyConditionCall) DoAndReturn(f func } // Remove mocks base method. -func (m *MockInstanceDomainRepository) Remove(arg0 context.Context, arg1 database.QueryExecutor, arg2 database.Condition) (int64, error) { +func (m *MockInstanceDomainRepository) Remove(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Remove", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Remove", ctx, client, condition) ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) return ret0, ret1 } // Remove indicates an expected call of Remove. -func (mr *MockInstanceDomainRepositoryMockRecorder) Remove(arg0, arg1, arg2 any) *MockInstanceDomainRepositoryRemoveCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) Remove(ctx, client, condition any) *MockInstanceDomainRepositoryRemoveCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockInstanceDomainRepository)(nil).Remove), arg0, arg1, arg2) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockInstanceDomainRepository)(nil).Remove), ctx, client, condition) return &MockInstanceDomainRepositoryRemoveCall{Call: call} } @@ -626,17 +627,17 @@ func (c *MockInstanceDomainRepositorySetPrimaryCall) DoAndReturn(f func() databa } // SetType mocks base method. -func (m *MockInstanceDomainRepository) SetType(arg0 domain.DomainType) database.Change { +func (m *MockInstanceDomainRepository) SetType(typ domain.DomainType) database.Change { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetType", arg0) + ret := m.ctrl.Call(m, "SetType", typ) ret0, _ := ret[0].(database.Change) return ret0 } // SetType indicates an expected call of SetType. -func (mr *MockInstanceDomainRepositoryMockRecorder) SetType(arg0 any) *MockInstanceDomainRepositorySetTypeCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) SetType(typ any) *MockInstanceDomainRepositorySetTypeCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetType", reflect.TypeOf((*MockInstanceDomainRepository)(nil).SetType), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetType", reflect.TypeOf((*MockInstanceDomainRepository)(nil).SetType), typ) return &MockInstanceDomainRepositorySetTypeCall{Call: call} } @@ -664,17 +665,17 @@ func (c *MockInstanceDomainRepositorySetTypeCall) DoAndReturn(f func(domain.Doma } // SetUpdatedAt mocks base method. -func (m *MockInstanceDomainRepository) SetUpdatedAt(arg0 time.Time) database.Change { +func (m *MockInstanceDomainRepository) SetUpdatedAt(t time.Time) database.Change { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetUpdatedAt", arg0) + ret := m.ctrl.Call(m, "SetUpdatedAt", t) ret0, _ := ret[0].(database.Change) return ret0 } // SetUpdatedAt indicates an expected call of SetUpdatedAt. -func (mr *MockInstanceDomainRepositoryMockRecorder) SetUpdatedAt(arg0 any) *MockInstanceDomainRepositorySetUpdatedAtCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) SetUpdatedAt(t any) *MockInstanceDomainRepositorySetUpdatedAtCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockInstanceDomainRepository)(nil).SetUpdatedAt), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockInstanceDomainRepository)(nil).SetUpdatedAt), t) return &MockInstanceDomainRepositorySetUpdatedAtCall{Call: call} } @@ -740,17 +741,17 @@ func (c *MockInstanceDomainRepositoryTypeColumnCall) DoAndReturn(f func() databa } // TypeCondition mocks base method. -func (m *MockInstanceDomainRepository) TypeCondition(arg0 domain.DomainType) database.Condition { +func (m *MockInstanceDomainRepository) TypeCondition(typ domain.DomainType) database.Condition { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TypeCondition", arg0) + ret := m.ctrl.Call(m, "TypeCondition", typ) ret0, _ := ret[0].(database.Condition) return ret0 } // TypeCondition indicates an expected call of TypeCondition. -func (mr *MockInstanceDomainRepositoryMockRecorder) TypeCondition(arg0 any) *MockInstanceDomainRepositoryTypeConditionCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) TypeCondition(typ any) *MockInstanceDomainRepositoryTypeConditionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).TypeCondition), arg0) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).TypeCondition), typ) return &MockInstanceDomainRepositoryTypeConditionCall{Call: call} } @@ -778,10 +779,10 @@ func (c *MockInstanceDomainRepositoryTypeConditionCall) DoAndReturn(f func(domai } // Update mocks base method. -func (m *MockInstanceDomainRepository) Update(arg0 context.Context, arg1 database.QueryExecutor, arg2 database.Condition, arg3 ...database.Change) (int64, error) { +func (m *MockInstanceDomainRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) { m.ctrl.T.Helper() - varargs := []any{arg0, arg1, arg2} - for _, a := range arg3 { + varargs := []any{ctx, client, condition} + for _, a := range changes { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Update", varargs...) @@ -791,9 +792,9 @@ func (m *MockInstanceDomainRepository) Update(arg0 context.Context, arg1 databas } // Update indicates an expected call of Update. -func (mr *MockInstanceDomainRepositoryMockRecorder) Update(arg0, arg1, arg2 any, arg3 ...any) *MockInstanceDomainRepositoryUpdateCall { +func (mr *MockInstanceDomainRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockInstanceDomainRepositoryUpdateCall { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1, arg2}, arg3...) + varargs := append([]any{ctx, client, condition}, changes...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInstanceDomainRepository)(nil).Update), varargs...) return &MockInstanceDomainRepositoryUpdateCall{Call: call} } diff --git a/backend/v3/domain/mock/machine_user.mock.go b/backend/v3/domain/mock/machine_user.mock.go new file mode 100644 index 000000000..9d3e7e40a --- /dev/null +++ b/backend/v3/domain/mock/machine_user.mock.go @@ -0,0 +1,1156 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: MachineUserRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/machine_user.mock.go . MachineUserRepository +// + +// 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" +) + +// MockMachineUserRepository is a mock of MachineUserRepository interface. +type MockMachineUserRepository struct { + ctrl *gomock.Controller + recorder *MockMachineUserRepositoryMockRecorder + isgomock struct{} +} + +// MockMachineUserRepositoryMockRecorder is the mock recorder for MockMachineUserRepository. +type MockMachineUserRepositoryMockRecorder struct { + mock *MockMachineUserRepository +} + +// NewMockMachineUserRepository creates a new mock instance. +func NewMockMachineUserRepository(ctrl *gomock.Controller) *MockMachineUserRepository { + mock := &MockMachineUserRepository{ctrl: ctrl} + mock.recorder = &MockMachineUserRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMachineUserRepository) EXPECT() *MockMachineUserRepositoryMockRecorder { + return m.recorder +} + +// AddKey mocks base method. +func (m *MockMachineUserRepository) AddKey(key *domain.MachineKey) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddKey", key) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// AddKey indicates an expected call of AddKey. +func (mr *MockMachineUserRepositoryMockRecorder) AddKey(key any) *MockMachineUserRepositoryAddKeyCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddKey", reflect.TypeOf((*MockMachineUserRepository)(nil).AddKey), key) + return &MockMachineUserRepositoryAddKeyCall{Call: call} +} + +// MockMachineUserRepositoryAddKeyCall wrap *gomock.Call +type MockMachineUserRepositoryAddKeyCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryAddKeyCall) Return(arg0 database.Change) *MockMachineUserRepositoryAddKeyCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryAddKeyCall) Do(f func(*domain.MachineKey) database.Change) *MockMachineUserRepositoryAddKeyCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryAddKeyCall) DoAndReturn(f func(*domain.MachineKey) database.Change) *MockMachineUserRepositoryAddKeyCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// AddMetadata mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) AddMetadata(metadata ...any) *MockMachineUserRepositoryAddMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMetadata", reflect.TypeOf((*MockMachineUserRepository)(nil).AddMetadata), metadata...) + return &MockMachineUserRepositoryAddMetadataCall{Call: call} +} + +// MockMachineUserRepositoryAddMetadataCall wrap *gomock.Call +type MockMachineUserRepositoryAddMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryAddMetadataCall) Return(arg0 database.Change) *MockMachineUserRepositoryAddMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryAddMetadataCall) Do(f func(...*domain.Metadata) database.Change) *MockMachineUserRepositoryAddMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryAddMetadataCall) DoAndReturn(f func(...*domain.Metadata) database.Change) *MockMachineUserRepositoryAddMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// AddPersonalAccessToken mocks base method. +func (m *MockMachineUserRepository) AddPersonalAccessToken(pat *domain.PersonalAccessToken) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddPersonalAccessToken", pat) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// AddPersonalAccessToken indicates an expected call of AddPersonalAccessToken. +func (mr *MockMachineUserRepositoryMockRecorder) AddPersonalAccessToken(pat any) *MockMachineUserRepositoryAddPersonalAccessTokenCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPersonalAccessToken", reflect.TypeOf((*MockMachineUserRepository)(nil).AddPersonalAccessToken), pat) + return &MockMachineUserRepositoryAddPersonalAccessTokenCall{Call: call} +} + +// MockMachineUserRepositoryAddPersonalAccessTokenCall wrap *gomock.Call +type MockMachineUserRepositoryAddPersonalAccessTokenCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryAddPersonalAccessTokenCall) Return(arg0 database.Change) *MockMachineUserRepositoryAddPersonalAccessTokenCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryAddPersonalAccessTokenCall) Do(f func(*domain.PersonalAccessToken) database.Change) *MockMachineUserRepositoryAddPersonalAccessTokenCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryAddPersonalAccessTokenCall) DoAndReturn(f func(*domain.PersonalAccessToken) database.Change) *MockMachineUserRepositoryAddPersonalAccessTokenCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreatedAtColumn mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) CreatedAtColumn() *MockMachineUserRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockMachineUserRepository)(nil).CreatedAtColumn)) + return &MockMachineUserRepositoryCreatedAtColumnCall{Call: call} +} + +// MockMachineUserRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockMachineUserRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockMachineUserRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockMachineUserRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockMachineUserRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ExistsMetadata mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) ExistsMetadata(condition any) *MockMachineUserRepositoryExistsMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsMetadata", reflect.TypeOf((*MockMachineUserRepository)(nil).ExistsMetadata), condition) + return &MockMachineUserRepositoryExistsMetadataCall{Call: call} +} + +// MockMachineUserRepositoryExistsMetadataCall wrap *gomock.Call +type MockMachineUserRepositoryExistsMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryExistsMetadataCall) Return(arg0 database.Condition) *MockMachineUserRepositoryExistsMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryExistsMetadataCall) Do(f func(database.Condition) database.Condition) *MockMachineUserRepositoryExistsMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryExistsMetadataCall) DoAndReturn(f func(database.Condition) database.Condition) *MockMachineUserRepositoryExistsMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) IDCondition(userID any) *MockMachineUserRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).IDCondition), userID) + return &MockMachineUserRepositoryIDConditionCall{Call: call} +} + +// MockMachineUserRepositoryIDConditionCall wrap *gomock.Call +type MockMachineUserRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryIDConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockMachineUserRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockMachineUserRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockMachineUserRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).InstanceIDCondition), instanceID) + return &MockMachineUserRepositoryInstanceIDConditionCall{Call: call} +} + +// MockMachineUserRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockMachineUserRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockMachineUserRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockMachineUserRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoginNameCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) LoginNameCondition(op, loginName any) *MockMachineUserRepositoryLoginNameConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoginNameCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).LoginNameCondition), op, loginName) + return &MockMachineUserRepositoryLoginNameConditionCall{Call: call} +} + +// MockMachineUserRepositoryLoginNameConditionCall wrap *gomock.Call +type MockMachineUserRepositoryLoginNameConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryLoginNameConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryLoginNameConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryLoginNameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockMachineUserRepositoryLoginNameConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryLoginNameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockMachineUserRepositoryLoginNameConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MetadataKeyCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) MetadataKeyCondition(key any) *MockMachineUserRepositoryMetadataKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataKeyCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).MetadataKeyCondition), key) + return &MockMachineUserRepositoryMetadataKeyConditionCall{Call: call} +} + +// MockMachineUserRepositoryMetadataKeyConditionCall wrap *gomock.Call +type MockMachineUserRepositoryMetadataKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryMetadataKeyConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryMetadataKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryMetadataKeyConditionCall) Do(f func(string) database.Condition) *MockMachineUserRepositoryMetadataKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryMetadataKeyConditionCall) DoAndReturn(f func(string) database.Condition) *MockMachineUserRepositoryMetadataKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MetadataValueCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) MetadataValueCondition(op, value any) *MockMachineUserRepositoryMetadataValueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataValueCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).MetadataValueCondition), op, value) + return &MockMachineUserRepositoryMetadataValueConditionCall{Call: call} +} + +// MockMachineUserRepositoryMetadataValueConditionCall wrap *gomock.Call +type MockMachineUserRepositoryMetadataValueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryMetadataValueConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryMetadataValueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryMetadataValueConditionCall) Do(f func(database.BytesOperation, []byte) database.Condition) *MockMachineUserRepositoryMetadataValueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryMetadataValueConditionCall) DoAndReturn(f func(database.BytesOperation, []byte) database.Condition) *MockMachineUserRepositoryMetadataValueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrgIDCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) OrgIDCondition(orgID any) *MockMachineUserRepositoryOrgIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrgIDCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).OrgIDCondition), orgID) + return &MockMachineUserRepositoryOrgIDConditionCall{Call: call} +} + +// MockMachineUserRepositoryOrgIDConditionCall wrap *gomock.Call +type MockMachineUserRepositoryOrgIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryOrgIDConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryOrgIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryOrgIDConditionCall) Do(f func(string) database.Condition) *MockMachineUserRepositoryOrgIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryOrgIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockMachineUserRepositoryOrgIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) PrimaryKeyColumns() *MockMachineUserRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockMachineUserRepository)(nil).PrimaryKeyColumns)) + return &MockMachineUserRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockMachineUserRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockMachineUserRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockMachineUserRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockMachineUserRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockMachineUserRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) PrimaryKeyCondition(instanceID, userID any) *MockMachineUserRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).PrimaryKeyCondition), instanceID, userID) + return &MockMachineUserRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockMachineUserRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockMachineUserRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockMachineUserRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockMachineUserRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveKey mocks base method. +func (m *MockMachineUserRepository) RemoveKey(id string) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveKey", id) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// RemoveKey indicates an expected call of RemoveKey. +func (mr *MockMachineUserRepositoryMockRecorder) RemoveKey(id any) *MockMachineUserRepositoryRemoveKeyCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveKey", reflect.TypeOf((*MockMachineUserRepository)(nil).RemoveKey), id) + return &MockMachineUserRepositoryRemoveKeyCall{Call: call} +} + +// MockMachineUserRepositoryRemoveKeyCall wrap *gomock.Call +type MockMachineUserRepositoryRemoveKeyCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryRemoveKeyCall) Return(arg0 database.Change) *MockMachineUserRepositoryRemoveKeyCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryRemoveKeyCall) Do(f func(string) database.Change) *MockMachineUserRepositoryRemoveKeyCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryRemoveKeyCall) DoAndReturn(f func(string) database.Change) *MockMachineUserRepositoryRemoveKeyCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveMetadata mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) RemoveMetadata(condition any) *MockMachineUserRepositoryRemoveMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMetadata", reflect.TypeOf((*MockMachineUserRepository)(nil).RemoveMetadata), condition) + return &MockMachineUserRepositoryRemoveMetadataCall{Call: call} +} + +// MockMachineUserRepositoryRemoveMetadataCall wrap *gomock.Call +type MockMachineUserRepositoryRemoveMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryRemoveMetadataCall) Return(arg0 database.Change) *MockMachineUserRepositoryRemoveMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryRemoveMetadataCall) Do(f func(database.Condition) database.Change) *MockMachineUserRepositoryRemoveMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryRemoveMetadataCall) DoAndReturn(f func(database.Condition) database.Change) *MockMachineUserRepositoryRemoveMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemovePersonalAccessToken mocks base method. +func (m *MockMachineUserRepository) RemovePersonalAccessToken(id string) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemovePersonalAccessToken", id) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// RemovePersonalAccessToken indicates an expected call of RemovePersonalAccessToken. +func (mr *MockMachineUserRepositoryMockRecorder) RemovePersonalAccessToken(id any) *MockMachineUserRepositoryRemovePersonalAccessTokenCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePersonalAccessToken", reflect.TypeOf((*MockMachineUserRepository)(nil).RemovePersonalAccessToken), id) + return &MockMachineUserRepositoryRemovePersonalAccessTokenCall{Call: call} +} + +// MockMachineUserRepositoryRemovePersonalAccessTokenCall wrap *gomock.Call +type MockMachineUserRepositoryRemovePersonalAccessTokenCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryRemovePersonalAccessTokenCall) Return(arg0 database.Change) *MockMachineUserRepositoryRemovePersonalAccessTokenCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryRemovePersonalAccessTokenCall) Do(f func(string) database.Change) *MockMachineUserRepositoryRemovePersonalAccessTokenCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryRemovePersonalAccessTokenCall) DoAndReturn(f func(string) database.Change) *MockMachineUserRepositoryRemovePersonalAccessTokenCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetAccessTokenType mocks base method. +func (m *MockMachineUserRepository) SetAccessTokenType(tokenType domain.PersonalAccessTokenType) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetAccessTokenType", tokenType) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetAccessTokenType indicates an expected call of SetAccessTokenType. +func (mr *MockMachineUserRepositoryMockRecorder) SetAccessTokenType(tokenType any) *MockMachineUserRepositorySetAccessTokenTypeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccessTokenType", reflect.TypeOf((*MockMachineUserRepository)(nil).SetAccessTokenType), tokenType) + return &MockMachineUserRepositorySetAccessTokenTypeCall{Call: call} +} + +// MockMachineUserRepositorySetAccessTokenTypeCall wrap *gomock.Call +type MockMachineUserRepositorySetAccessTokenTypeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositorySetAccessTokenTypeCall) Return(arg0 database.Change) *MockMachineUserRepositorySetAccessTokenTypeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositorySetAccessTokenTypeCall) Do(f func(domain.PersonalAccessTokenType) database.Change) *MockMachineUserRepositorySetAccessTokenTypeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositorySetAccessTokenTypeCall) DoAndReturn(f func(domain.PersonalAccessTokenType) database.Change) *MockMachineUserRepositorySetAccessTokenTypeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetDescription mocks base method. +func (m *MockMachineUserRepository) SetDescription(description string) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDescription", description) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetDescription indicates an expected call of SetDescription. +func (mr *MockMachineUserRepositoryMockRecorder) SetDescription(description any) *MockMachineUserRepositorySetDescriptionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDescription", reflect.TypeOf((*MockMachineUserRepository)(nil).SetDescription), description) + return &MockMachineUserRepositorySetDescriptionCall{Call: call} +} + +// MockMachineUserRepositorySetDescriptionCall wrap *gomock.Call +type MockMachineUserRepositorySetDescriptionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositorySetDescriptionCall) Return(arg0 database.Change) *MockMachineUserRepositorySetDescriptionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositorySetDescriptionCall) Do(f func(string) database.Change) *MockMachineUserRepositorySetDescriptionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositorySetDescriptionCall) DoAndReturn(f func(string) database.Change) *MockMachineUserRepositorySetDescriptionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetName mocks base method. +func (m *MockMachineUserRepository) SetName(name string) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetName", name) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetName indicates an expected call of SetName. +func (mr *MockMachineUserRepositoryMockRecorder) SetName(name any) *MockMachineUserRepositorySetNameCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetName", reflect.TypeOf((*MockMachineUserRepository)(nil).SetName), name) + return &MockMachineUserRepositorySetNameCall{Call: call} +} + +// MockMachineUserRepositorySetNameCall wrap *gomock.Call +type MockMachineUserRepositorySetNameCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositorySetNameCall) Return(arg0 database.Change) *MockMachineUserRepositorySetNameCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositorySetNameCall) Do(f func(string) database.Change) *MockMachineUserRepositorySetNameCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositorySetNameCall) DoAndReturn(f func(string) database.Change) *MockMachineUserRepositorySetNameCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSecret mocks base method. +func (m *MockMachineUserRepository) SetSecret(secret *string) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSecret", secret) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSecret indicates an expected call of SetSecret. +func (mr *MockMachineUserRepositoryMockRecorder) SetSecret(secret any) *MockMachineUserRepositorySetSecretCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecret", reflect.TypeOf((*MockMachineUserRepository)(nil).SetSecret), secret) + return &MockMachineUserRepositorySetSecretCall{Call: call} +} + +// MockMachineUserRepositorySetSecretCall wrap *gomock.Call +type MockMachineUserRepositorySetSecretCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositorySetSecretCall) Return(arg0 database.Change) *MockMachineUserRepositorySetSecretCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositorySetSecretCall) Do(f func(*string) database.Change) *MockMachineUserRepositorySetSecretCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositorySetSecretCall) DoAndReturn(f func(*string) database.Change) *MockMachineUserRepositorySetSecretCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetState mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) SetState(state any) *MockMachineUserRepositorySetStateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockMachineUserRepository)(nil).SetState), state) + return &MockMachineUserRepositorySetStateCall{Call: call} +} + +// MockMachineUserRepositorySetStateCall wrap *gomock.Call +type MockMachineUserRepositorySetStateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositorySetStateCall) Return(arg0 database.Change) *MockMachineUserRepositorySetStateCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositorySetStateCall) Do(f func(domain.UserState) database.Change) *MockMachineUserRepositorySetStateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositorySetStateCall) DoAndReturn(f func(domain.UserState) database.Change) *MockMachineUserRepositorySetStateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockMachineUserRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockMachineUserRepository)(nil).SetUpdatedAt), updatedAt) + return &MockMachineUserRepositorySetUpdatedAtCall{Call: call} +} + +// MockMachineUserRepositorySetUpdatedAtCall wrap *gomock.Call +type MockMachineUserRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockMachineUserRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositorySetUpdatedAtCall) Do(f func(time.Time) database.Change) *MockMachineUserRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockMachineUserRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUsername mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) SetUsername(username any) *MockMachineUserRepositorySetUsernameCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUsername", reflect.TypeOf((*MockMachineUserRepository)(nil).SetUsername), username) + return &MockMachineUserRepositorySetUsernameCall{Call: call} +} + +// MockMachineUserRepositorySetUsernameCall wrap *gomock.Call +type MockMachineUserRepositorySetUsernameCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositorySetUsernameCall) Return(arg0 database.Change) *MockMachineUserRepositorySetUsernameCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositorySetUsernameCall) Do(f func(string) database.Change) *MockMachineUserRepositorySetUsernameCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositorySetUsernameCall) DoAndReturn(f func(string) database.Change) *MockMachineUserRepositorySetUsernameCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) StateColumn() *MockMachineUserRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockMachineUserRepository)(nil).StateColumn)) + return &MockMachineUserRepositoryStateColumnCall{Call: call} +} + +// MockMachineUserRepositoryStateColumnCall wrap *gomock.Call +type MockMachineUserRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryStateColumnCall) Return(arg0 database.Column) *MockMachineUserRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryStateColumnCall) Do(f func() database.Column) *MockMachineUserRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockMachineUserRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) StateCondition(state any) *MockMachineUserRepositoryStateConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).StateCondition), state) + return &MockMachineUserRepositoryStateConditionCall{Call: call} +} + +// MockMachineUserRepositoryStateConditionCall wrap *gomock.Call +type MockMachineUserRepositoryStateConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryStateConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryStateConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryStateConditionCall) Do(f func(domain.UserState) database.Condition) *MockMachineUserRepositoryStateConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryStateConditionCall) DoAndReturn(f func(domain.UserState) database.Condition) *MockMachineUserRepositoryStateConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) TypeCondition(userType any) *MockMachineUserRepositoryTypeConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).TypeCondition), userType) + return &MockMachineUserRepositoryTypeConditionCall{Call: call} +} + +// MockMachineUserRepositoryTypeConditionCall wrap *gomock.Call +type MockMachineUserRepositoryTypeConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryTypeConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryTypeConditionCall) Do(f func(domain.UserType) database.Condition) *MockMachineUserRepositoryTypeConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryTypeConditionCall) DoAndReturn(f func(domain.UserType) database.Condition) *MockMachineUserRepositoryTypeConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Update mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockMachineUserRepositoryUpdateCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client, condition}, changes...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockMachineUserRepository)(nil).Update), varargs...) + return &MockMachineUserRepositoryUpdateCall{Call: call} +} + +// MockMachineUserRepositoryUpdateCall wrap *gomock.Call +type MockMachineUserRepositoryUpdateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryUpdateCall) Return(arg0 int64, arg1 error) *MockMachineUserRepositoryUpdateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryUpdateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockMachineUserRepositoryUpdateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryUpdateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockMachineUserRepositoryUpdateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UsernameColumn mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) UsernameColumn() *MockMachineUserRepositoryUsernameColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsernameColumn", reflect.TypeOf((*MockMachineUserRepository)(nil).UsernameColumn)) + return &MockMachineUserRepositoryUsernameColumnCall{Call: call} +} + +// MockMachineUserRepositoryUsernameColumnCall wrap *gomock.Call +type MockMachineUserRepositoryUsernameColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryUsernameColumnCall) Return(arg0 database.Column) *MockMachineUserRepositoryUsernameColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryUsernameColumnCall) Do(f func() database.Column) *MockMachineUserRepositoryUsernameColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryUsernameColumnCall) DoAndReturn(f func() database.Column) *MockMachineUserRepositoryUsernameColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UsernameCondition mocks base method. +func (m *MockMachineUserRepository) 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 *MockMachineUserRepositoryMockRecorder) UsernameCondition(op, username any) *MockMachineUserRepositoryUsernameConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsernameCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).UsernameCondition), op, username) + return &MockMachineUserRepositoryUsernameConditionCall{Call: call} +} + +// MockMachineUserRepositoryUsernameConditionCall wrap *gomock.Call +type MockMachineUserRepositoryUsernameConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMachineUserRepositoryUsernameConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryUsernameConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMachineUserRepositoryUsernameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockMachineUserRepositoryUsernameConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMachineUserRepositoryUsernameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockMachineUserRepositoryUsernameConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/permission.mock.go b/backend/v3/domain/mock/permission.mock.go index 5d0f21150..24edd20eb 100644 --- a/backend/v3/domain/mock/permission.mock.go +++ b/backend/v3/domain/mock/permission.mock.go @@ -20,6 +20,7 @@ import ( type MockPermissionChecker struct { ctrl *gomock.Controller recorder *MockPermissionCheckerMockRecorder + isgomock struct{} } // MockPermissionCheckerMockRecorder is the mock recorder for MockPermissionChecker. @@ -40,17 +41,17 @@ func (m *MockPermissionChecker) EXPECT() *MockPermissionCheckerMockRecorder { } // CheckInstancePermission mocks base method. -func (m *MockPermissionChecker) CheckInstancePermission(arg0 context.Context, arg1 string) error { +func (m *MockPermissionChecker) CheckInstancePermission(ctx context.Context, permission string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckInstancePermission", arg0, arg1) + ret := m.ctrl.Call(m, "CheckInstancePermission", ctx, permission) ret0, _ := ret[0].(error) return ret0 } // CheckInstancePermission indicates an expected call of CheckInstancePermission. -func (mr *MockPermissionCheckerMockRecorder) CheckInstancePermission(arg0, arg1 any) *MockPermissionCheckerCheckInstancePermissionCall { +func (mr *MockPermissionCheckerMockRecorder) CheckInstancePermission(ctx, permission any) *MockPermissionCheckerCheckInstancePermissionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckInstancePermission", reflect.TypeOf((*MockPermissionChecker)(nil).CheckInstancePermission), arg0, arg1) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckInstancePermission", reflect.TypeOf((*MockPermissionChecker)(nil).CheckInstancePermission), ctx, permission) return &MockPermissionCheckerCheckInstancePermissionCall{Call: call} } @@ -78,17 +79,17 @@ func (c *MockPermissionCheckerCheckInstancePermissionCall) DoAndReturn(f func(co } // CheckOrganizationPermission mocks base method. -func (m *MockPermissionChecker) CheckOrganizationPermission(arg0 context.Context, arg1, arg2 string) error { +func (m *MockPermissionChecker) CheckOrganizationPermission(ctx context.Context, permission, orgID string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckOrganizationPermission", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "CheckOrganizationPermission", ctx, permission, orgID) ret0, _ := ret[0].(error) return ret0 } // CheckOrganizationPermission indicates an expected call of CheckOrganizationPermission. -func (mr *MockPermissionCheckerMockRecorder) CheckOrganizationPermission(arg0, arg1, arg2 any) *MockPermissionCheckerCheckOrganizationPermissionCall { +func (mr *MockPermissionCheckerMockRecorder) CheckOrganizationPermission(ctx, permission, orgID any) *MockPermissionCheckerCheckOrganizationPermissionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckOrganizationPermission", reflect.TypeOf((*MockPermissionChecker)(nil).CheckOrganizationPermission), arg0, arg1, arg2) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckOrganizationPermission", reflect.TypeOf((*MockPermissionChecker)(nil).CheckOrganizationPermission), ctx, permission, orgID) return &MockPermissionCheckerCheckOrganizationPermissionCall{Call: call} } @@ -116,17 +117,17 @@ func (c *MockPermissionCheckerCheckOrganizationPermissionCall) DoAndReturn(f fun } // CheckProjectGrantPermission mocks base method. -func (m *MockPermissionChecker) CheckProjectGrantPermission(arg0 context.Context, arg1, arg2 string) error { +func (m *MockPermissionChecker) CheckProjectGrantPermission(ctx context.Context, permission, projectGrantID string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckProjectGrantPermission", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "CheckProjectGrantPermission", ctx, permission, projectGrantID) ret0, _ := ret[0].(error) return ret0 } // CheckProjectGrantPermission indicates an expected call of CheckProjectGrantPermission. -func (mr *MockPermissionCheckerMockRecorder) CheckProjectGrantPermission(arg0, arg1, arg2 any) *MockPermissionCheckerCheckProjectGrantPermissionCall { +func (mr *MockPermissionCheckerMockRecorder) CheckProjectGrantPermission(ctx, permission, projectGrantID any) *MockPermissionCheckerCheckProjectGrantPermissionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckProjectGrantPermission", reflect.TypeOf((*MockPermissionChecker)(nil).CheckProjectGrantPermission), arg0, arg1, arg2) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckProjectGrantPermission", reflect.TypeOf((*MockPermissionChecker)(nil).CheckProjectGrantPermission), ctx, permission, projectGrantID) return &MockPermissionCheckerCheckProjectGrantPermissionCall{Call: call} } @@ -154,17 +155,17 @@ func (c *MockPermissionCheckerCheckProjectGrantPermissionCall) DoAndReturn(f fun } // CheckProjectPermission mocks base method. -func (m *MockPermissionChecker) CheckProjectPermission(arg0 context.Context, arg1, arg2 string) error { +func (m *MockPermissionChecker) CheckProjectPermission(ctx context.Context, permission, projectID string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckProjectPermission", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "CheckProjectPermission", ctx, permission, projectID) ret0, _ := ret[0].(error) return ret0 } // CheckProjectPermission indicates an expected call of CheckProjectPermission. -func (mr *MockPermissionCheckerMockRecorder) CheckProjectPermission(arg0, arg1, arg2 any) *MockPermissionCheckerCheckProjectPermissionCall { +func (mr *MockPermissionCheckerMockRecorder) CheckProjectPermission(ctx, permission, projectID any) *MockPermissionCheckerCheckProjectPermissionCall { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckProjectPermission", reflect.TypeOf((*MockPermissionChecker)(nil).CheckProjectPermission), arg0, arg1, arg2) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckProjectPermission", reflect.TypeOf((*MockPermissionChecker)(nil).CheckProjectPermission), ctx, permission, projectID) return &MockPermissionCheckerCheckProjectPermissionCall{Call: call} } diff --git a/backend/v3/domain/mock/session.mock.go b/backend/v3/domain/mock/session.mock.go new file mode 100644 index 000000000..ad700dab9 --- /dev/null +++ b/backend/v3/domain/mock/session.mock.go @@ -0,0 +1,1392 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: SessionRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/session.mock.go . SessionRepository +// + +// 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" +) + +// MockSessionRepository is a mock of SessionRepository interface. +type MockSessionRepository struct { + ctrl *gomock.Controller + recorder *MockSessionRepositoryMockRecorder + isgomock struct{} +} + +// MockSessionRepositoryMockRecorder is the mock recorder for MockSessionRepository. +type MockSessionRepositoryMockRecorder struct { + mock *MockSessionRepository +} + +// NewMockSessionRepository creates a new mock instance. +func NewMockSessionRepository(ctrl *gomock.Controller) *MockSessionRepository { + mock := &MockSessionRepository{ctrl: ctrl} + mock.recorder = &MockSessionRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSessionRepository) EXPECT() *MockSessionRepositoryMockRecorder { + return m.recorder +} + +// ClearFactor mocks base method. +func (m *MockSessionRepository) ClearFactor(factor domain.SessionFactorType) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClearFactor", factor) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// ClearFactor indicates an expected call of ClearFactor. +func (mr *MockSessionRepositoryMockRecorder) ClearFactor(factor any) *MockSessionRepositoryClearFactorCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearFactor", reflect.TypeOf((*MockSessionRepository)(nil).ClearFactor), factor) + return &MockSessionRepositoryClearFactorCall{Call: call} +} + +// MockSessionRepositoryClearFactorCall wrap *gomock.Call +type MockSessionRepositoryClearFactorCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryClearFactorCall) Return(arg0 database.Change) *MockSessionRepositoryClearFactorCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryClearFactorCall) Do(f func(domain.SessionFactorType) database.Change) *MockSessionRepositoryClearFactorCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryClearFactorCall) DoAndReturn(f func(domain.SessionFactorType) database.Change) *MockSessionRepositoryClearFactorCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Create mocks base method. +func (m *MockSessionRepository) Create(ctx context.Context, client database.QueryExecutor, user *domain.Session) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", ctx, client, user) + ret0, _ := ret[0].(error) + return ret0 +} + +// Create indicates an expected call of Create. +func (mr *MockSessionRepositoryMockRecorder) Create(ctx, client, user any) *MockSessionRepositoryCreateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSessionRepository)(nil).Create), ctx, client, user) + return &MockSessionRepositoryCreateCall{Call: call} +} + +// MockSessionRepositoryCreateCall wrap *gomock.Call +type MockSessionRepositoryCreateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryCreateCall) Return(arg0 error) *MockSessionRepositoryCreateCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryCreateCall) Do(f func(context.Context, database.QueryExecutor, *domain.Session) error) *MockSessionRepositoryCreateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryCreateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.Session) error) *MockSessionRepositoryCreateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreatedAtColumn mocks base method. +func (m *MockSessionRepository) 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 *MockSessionRepositoryMockRecorder) CreatedAtColumn() *MockSessionRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockSessionRepository)(nil).CreatedAtColumn)) + return &MockSessionRepositoryCreatedAtColumnCall{Call: call} +} + +// MockSessionRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockSessionRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockSessionRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockSessionRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreatedAtCondition mocks base method. +func (m *MockSessionRepository) CreatedAtCondition(op database.NumberOperation, createdAt time.Time) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtCondition", op, createdAt) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// CreatedAtCondition indicates an expected call of CreatedAtCondition. +func (mr *MockSessionRepositoryMockRecorder) CreatedAtCondition(op, createdAt any) *MockSessionRepositoryCreatedAtConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatedAtCondition), op, createdAt) + return &MockSessionRepositoryCreatedAtConditionCall{Call: call} +} + +// MockSessionRepositoryCreatedAtConditionCall wrap *gomock.Call +type MockSessionRepositoryCreatedAtConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryCreatedAtConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryCreatedAtConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryCreatedAtConditionCall) Do(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryCreatedAtConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryCreatedAtConditionCall) DoAndReturn(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryCreatedAtConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockSessionRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockSessionRepositoryMockRecorder) Delete(ctx, client, condition any) *MockSessionRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSessionRepository)(nil).Delete), ctx, client, condition) + return &MockSessionRepositoryDeleteCall{Call: call} +} + +// MockSessionRepositoryDeleteCall wrap *gomock.Call +type MockSessionRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryDeleteCall) Return(arg0 error) *MockSessionRepositoryDeleteCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) error) *MockSessionRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) error) *MockSessionRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ExpirationColumn mocks base method. +func (m *MockSessionRepository) ExpirationColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpirationColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// ExpirationColumn indicates an expected call of ExpirationColumn. +func (mr *MockSessionRepositoryMockRecorder) ExpirationColumn() *MockSessionRepositoryExpirationColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpirationColumn", reflect.TypeOf((*MockSessionRepository)(nil).ExpirationColumn)) + return &MockSessionRepositoryExpirationColumnCall{Call: call} +} + +// MockSessionRepositoryExpirationColumnCall wrap *gomock.Call +type MockSessionRepositoryExpirationColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryExpirationColumnCall) Return(arg0 database.Column) *MockSessionRepositoryExpirationColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryExpirationColumnCall) Do(f func() database.Column) *MockSessionRepositoryExpirationColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryExpirationColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryExpirationColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// FactorColumns mocks base method. +func (m *MockSessionRepository) FactorColumns() domain.SessionFactorColumns { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FactorColumns") + ret0, _ := ret[0].(domain.SessionFactorColumns) + return ret0 +} + +// FactorColumns indicates an expected call of FactorColumns. +func (mr *MockSessionRepositoryMockRecorder) FactorColumns() *MockSessionRepositoryFactorColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FactorColumns", reflect.TypeOf((*MockSessionRepository)(nil).FactorColumns)) + return &MockSessionRepositoryFactorColumnsCall{Call: call} +} + +// MockSessionRepositoryFactorColumnsCall wrap *gomock.Call +type MockSessionRepositoryFactorColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryFactorColumnsCall) Return(arg0 domain.SessionFactorColumns) *MockSessionRepositoryFactorColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryFactorColumnsCall) Do(f func() domain.SessionFactorColumns) *MockSessionRepositoryFactorColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryFactorColumnsCall) DoAndReturn(f func() domain.SessionFactorColumns) *MockSessionRepositoryFactorColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// FactorConditions mocks base method. +func (m *MockSessionRepository) FactorConditions() domain.SessionFactorConditions { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FactorConditions") + ret0, _ := ret[0].(domain.SessionFactorConditions) + return ret0 +} + +// FactorConditions indicates an expected call of FactorConditions. +func (mr *MockSessionRepositoryMockRecorder) FactorConditions() *MockSessionRepositoryFactorConditionsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FactorConditions", reflect.TypeOf((*MockSessionRepository)(nil).FactorConditions)) + return &MockSessionRepositoryFactorConditionsCall{Call: call} +} + +// MockSessionRepositoryFactorConditionsCall wrap *gomock.Call +type MockSessionRepositoryFactorConditionsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryFactorConditionsCall) Return(arg0 domain.SessionFactorConditions) *MockSessionRepositoryFactorConditionsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryFactorConditionsCall) Do(f func() domain.SessionFactorConditions) *MockSessionRepositoryFactorConditionsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryFactorConditionsCall) DoAndReturn(f func() domain.SessionFactorConditions) *MockSessionRepositoryFactorConditionsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockSessionRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.Session, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.Session) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockSessionRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockSessionRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSessionRepository)(nil).Get), varargs...) + return &MockSessionRepositoryGetCall{Call: call} +} + +// MockSessionRepositoryGetCall wrap *gomock.Call +type MockSessionRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryGetCall) Return(arg0 *domain.Session, arg1 error) *MockSessionRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.Session, error)) *MockSessionRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.Session, error)) *MockSessionRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockSessionRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockSessionRepositoryMockRecorder) IDColumn() *MockSessionRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockSessionRepository)(nil).IDColumn)) + return &MockSessionRepositoryIDColumnCall{Call: call} +} + +// MockSessionRepositoryIDColumnCall wrap *gomock.Call +type MockSessionRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryIDColumnCall) Return(arg0 database.Column) *MockSessionRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryIDColumnCall) Do(f func() database.Column) *MockSessionRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockSessionRepository) IDCondition(sessionID string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", sessionID) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockSessionRepositoryMockRecorder) IDCondition(sessionID any) *MockSessionRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSessionRepository)(nil).IDCondition), sessionID) + return &MockSessionRepositoryIDConditionCall{Call: call} +} + +// MockSessionRepositoryIDConditionCall wrap *gomock.Call +type MockSessionRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockSessionRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockSessionRepositoryMockRecorder) InstanceIDColumn() *MockSessionRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockSessionRepository)(nil).InstanceIDColumn)) + return &MockSessionRepositoryInstanceIDColumnCall{Call: call} +} + +// MockSessionRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockSessionRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockSessionRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockSessionRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockSessionRepository) 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 *MockSessionRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockSessionRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).InstanceIDCondition), instanceID) + return &MockSessionRepositoryInstanceIDConditionCall{Call: call} +} + +// MockSessionRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockSessionRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LifetimeColumn mocks base method. +func (m *MockSessionRepository) LifetimeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LifetimeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// LifetimeColumn indicates an expected call of LifetimeColumn. +func (mr *MockSessionRepositoryMockRecorder) LifetimeColumn() *MockSessionRepositoryLifetimeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LifetimeColumn", reflect.TypeOf((*MockSessionRepository)(nil).LifetimeColumn)) + return &MockSessionRepositoryLifetimeColumnCall{Call: call} +} + +// MockSessionRepositoryLifetimeColumnCall wrap *gomock.Call +type MockSessionRepositoryLifetimeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryLifetimeColumnCall) Return(arg0 database.Column) *MockSessionRepositoryLifetimeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryLifetimeColumnCall) Do(f func() database.Column) *MockSessionRepositoryLifetimeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryLifetimeColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryLifetimeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockSessionRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.Session, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.Session) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockSessionRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockSessionRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSessionRepository)(nil).List), varargs...) + return &MockSessionRepositoryListCall{Call: call} +} + +// MockSessionRepositoryListCall wrap *gomock.Call +type MockSessionRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryListCall) Return(arg0 []*domain.Session, arg1 error) *MockSessionRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.Session, error)) *MockSessionRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.Session, error)) *MockSessionRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MetadataColumns mocks base method. +func (m *MockSessionRepository) MetadataColumns() domain.SessionMetadataColumns { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MetadataColumns") + ret0, _ := ret[0].(domain.SessionMetadataColumns) + return ret0 +} + +// MetadataColumns indicates an expected call of MetadataColumns. +func (mr *MockSessionRepositoryMockRecorder) MetadataColumns() *MockSessionRepositoryMetadataColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataColumns", reflect.TypeOf((*MockSessionRepository)(nil).MetadataColumns)) + return &MockSessionRepositoryMetadataColumnsCall{Call: call} +} + +// MockSessionRepositoryMetadataColumnsCall wrap *gomock.Call +type MockSessionRepositoryMetadataColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryMetadataColumnsCall) Return(arg0 domain.SessionMetadataColumns) *MockSessionRepositoryMetadataColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryMetadataColumnsCall) Do(f func() domain.SessionMetadataColumns) *MockSessionRepositoryMetadataColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryMetadataColumnsCall) DoAndReturn(f func() domain.SessionMetadataColumns) *MockSessionRepositoryMetadataColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MetadataConditions mocks base method. +func (m *MockSessionRepository) MetadataConditions() domain.SessionMetadataConditions { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MetadataConditions") + ret0, _ := ret[0].(domain.SessionMetadataConditions) + return ret0 +} + +// MetadataConditions indicates an expected call of MetadataConditions. +func (mr *MockSessionRepositoryMockRecorder) MetadataConditions() *MockSessionRepositoryMetadataConditionsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataConditions", reflect.TypeOf((*MockSessionRepository)(nil).MetadataConditions)) + return &MockSessionRepositoryMetadataConditionsCall{Call: call} +} + +// MockSessionRepositoryMetadataConditionsCall wrap *gomock.Call +type MockSessionRepositoryMetadataConditionsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryMetadataConditionsCall) Return(arg0 domain.SessionMetadataConditions) *MockSessionRepositoryMetadataConditionsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryMetadataConditionsCall) Do(f func() domain.SessionMetadataConditions) *MockSessionRepositoryMetadataConditionsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryMetadataConditionsCall) DoAndReturn(f func() domain.SessionMetadataConditions) *MockSessionRepositoryMetadataConditionsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockSessionRepository) 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 *MockSessionRepositoryMockRecorder) PrimaryKeyColumns() *MockSessionRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockSessionRepository)(nil).PrimaryKeyColumns)) + return &MockSessionRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockSessionRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockSessionRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockSessionRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockSessionRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockSessionRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockSessionRepository) PrimaryKeyCondition(instanceID, sessionID string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, sessionID) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockSessionRepositoryMockRecorder) PrimaryKeyCondition(instanceID, sessionID any) *MockSessionRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockSessionRepository)(nil).PrimaryKeyCondition), instanceID, sessionID) + return &MockSessionRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockSessionRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockSessionRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockSessionRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockSessionRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetChallenge mocks base method. +func (m *MockSessionRepository) SetChallenge(challenge domain.SessionChallenge) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetChallenge", challenge) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetChallenge indicates an expected call of SetChallenge. +func (mr *MockSessionRepositoryMockRecorder) SetChallenge(challenge any) *MockSessionRepositorySetChallengeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChallenge", reflect.TypeOf((*MockSessionRepository)(nil).SetChallenge), challenge) + return &MockSessionRepositorySetChallengeCall{Call: call} +} + +// MockSessionRepositorySetChallengeCall wrap *gomock.Call +type MockSessionRepositorySetChallengeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositorySetChallengeCall) Return(arg0 database.Change) *MockSessionRepositorySetChallengeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositorySetChallengeCall) Do(f func(domain.SessionChallenge) database.Change) *MockSessionRepositorySetChallengeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositorySetChallengeCall) DoAndReturn(f func(domain.SessionChallenge) database.Change) *MockSessionRepositorySetChallengeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetFactor mocks base method. +func (m *MockSessionRepository) SetFactor(factor domain.SessionFactor) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetFactor", factor) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetFactor indicates an expected call of SetFactor. +func (mr *MockSessionRepositoryMockRecorder) SetFactor(factor any) *MockSessionRepositorySetFactorCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFactor", reflect.TypeOf((*MockSessionRepository)(nil).SetFactor), factor) + return &MockSessionRepositorySetFactorCall{Call: call} +} + +// MockSessionRepositorySetFactorCall wrap *gomock.Call +type MockSessionRepositorySetFactorCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositorySetFactorCall) Return(arg0 database.Change) *MockSessionRepositorySetFactorCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositorySetFactorCall) Do(f func(domain.SessionFactor) database.Change) *MockSessionRepositorySetFactorCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositorySetFactorCall) DoAndReturn(f func(domain.SessionFactor) database.Change) *MockSessionRepositorySetFactorCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetLifetime mocks base method. +func (m *MockSessionRepository) SetLifetime(lifetime time.Duration) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetLifetime", lifetime) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetLifetime indicates an expected call of SetLifetime. +func (mr *MockSessionRepositoryMockRecorder) SetLifetime(lifetime any) *MockSessionRepositorySetLifetimeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLifetime", reflect.TypeOf((*MockSessionRepository)(nil).SetLifetime), lifetime) + return &MockSessionRepositorySetLifetimeCall{Call: call} +} + +// MockSessionRepositorySetLifetimeCall wrap *gomock.Call +type MockSessionRepositorySetLifetimeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositorySetLifetimeCall) Return(arg0 database.Change) *MockSessionRepositorySetLifetimeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositorySetLifetimeCall) Do(f func(time.Duration) database.Change) *MockSessionRepositorySetLifetimeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositorySetLifetimeCall) DoAndReturn(f func(time.Duration) database.Change) *MockSessionRepositorySetLifetimeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetMetadata mocks base method. +func (m *MockSessionRepository) SetMetadata(metadata []domain.SessionMetadata) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMetadata", metadata) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetMetadata indicates an expected call of SetMetadata. +func (mr *MockSessionRepositoryMockRecorder) SetMetadata(metadata any) *MockSessionRepositorySetMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockSessionRepository)(nil).SetMetadata), metadata) + return &MockSessionRepositorySetMetadataCall{Call: call} +} + +// MockSessionRepositorySetMetadataCall wrap *gomock.Call +type MockSessionRepositorySetMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositorySetMetadataCall) Return(arg0 database.Change) *MockSessionRepositorySetMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositorySetMetadataCall) Do(f func([]domain.SessionMetadata) database.Change) *MockSessionRepositorySetMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositorySetMetadataCall) DoAndReturn(f func([]domain.SessionMetadata) database.Change) *MockSessionRepositorySetMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetToken mocks base method. +func (m *MockSessionRepository) SetToken(token string) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetToken", token) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetToken indicates an expected call of SetToken. +func (mr *MockSessionRepositoryMockRecorder) SetToken(token any) *MockSessionRepositorySetTokenCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetToken", reflect.TypeOf((*MockSessionRepository)(nil).SetToken), token) + return &MockSessionRepositorySetTokenCall{Call: call} +} + +// MockSessionRepositorySetTokenCall wrap *gomock.Call +type MockSessionRepositorySetTokenCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositorySetTokenCall) Return(arg0 database.Change) *MockSessionRepositorySetTokenCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositorySetTokenCall) Do(f func(string) database.Change) *MockSessionRepositorySetTokenCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositorySetTokenCall) DoAndReturn(f func(string) database.Change) *MockSessionRepositorySetTokenCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockSessionRepository) 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 *MockSessionRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockSessionRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockSessionRepository)(nil).SetUpdatedAt), updatedAt) + return &MockSessionRepositorySetUpdatedAtCall{Call: call} +} + +// MockSessionRepositorySetUpdatedAtCall wrap *gomock.Call +type MockSessionRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockSessionRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositorySetUpdatedAtCall) Do(f func(time.Time) database.Change) *MockSessionRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockSessionRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUserAgent mocks base method. +func (m *MockSessionRepository) SetUserAgent(userAgent domain.SessionUserAgent) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUserAgent", userAgent) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUserAgent indicates an expected call of SetUserAgent. +func (mr *MockSessionRepositoryMockRecorder) SetUserAgent(userAgent any) *MockSessionRepositorySetUserAgentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAgent", reflect.TypeOf((*MockSessionRepository)(nil).SetUserAgent), userAgent) + return &MockSessionRepositorySetUserAgentCall{Call: call} +} + +// MockSessionRepositorySetUserAgentCall wrap *gomock.Call +type MockSessionRepositorySetUserAgentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositorySetUserAgentCall) Return(arg0 database.Change) *MockSessionRepositorySetUserAgentCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositorySetUserAgentCall) Do(f func(domain.SessionUserAgent) database.Change) *MockSessionRepositorySetUserAgentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositorySetUserAgentCall) DoAndReturn(f func(domain.SessionUserAgent) database.Change) *MockSessionRepositorySetUserAgentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TokenColumn mocks base method. +func (m *MockSessionRepository) TokenColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TokenColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TokenColumn indicates an expected call of TokenColumn. +func (mr *MockSessionRepositoryMockRecorder) TokenColumn() *MockSessionRepositoryTokenColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenColumn", reflect.TypeOf((*MockSessionRepository)(nil).TokenColumn)) + return &MockSessionRepositoryTokenColumnCall{Call: call} +} + +// MockSessionRepositoryTokenColumnCall wrap *gomock.Call +type MockSessionRepositoryTokenColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryTokenColumnCall) Return(arg0 database.Column) *MockSessionRepositoryTokenColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryTokenColumnCall) Do(f func() database.Column) *MockSessionRepositoryTokenColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryTokenColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryTokenColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Update mocks base method. +func (m *MockSessionRepository) 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 *MockSessionRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockSessionRepositoryUpdateCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client, condition}, changes...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSessionRepository)(nil).Update), varargs...) + return &MockSessionRepositoryUpdateCall{Call: call} +} + +// MockSessionRepositoryUpdateCall wrap *gomock.Call +type MockSessionRepositoryUpdateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryUpdateCall) Return(arg0 int64, arg1 error) *MockSessionRepositoryUpdateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryUpdateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockSessionRepositoryUpdateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryUpdateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockSessionRepositoryUpdateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockSessionRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockSessionRepositoryMockRecorder) UpdatedAtColumn() *MockSessionRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockSessionRepository)(nil).UpdatedAtColumn)) + return &MockSessionRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockSessionRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockSessionRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockSessionRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockSessionRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtCondition mocks base method. +func (m *MockSessionRepository) UpdatedAtCondition(op database.NumberOperation, updatedAt time.Time) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtCondition", op, updatedAt) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UpdatedAtCondition indicates an expected call of UpdatedAtCondition. +func (mr *MockSessionRepositoryMockRecorder) UpdatedAtCondition(op, updatedAt any) *MockSessionRepositoryUpdatedAtConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).UpdatedAtCondition), op, updatedAt) + return &MockSessionRepositoryUpdatedAtConditionCall{Call: call} +} + +// MockSessionRepositoryUpdatedAtConditionCall wrap *gomock.Call +type MockSessionRepositoryUpdatedAtConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryUpdatedAtConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryUpdatedAtConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryUpdatedAtConditionCall) Do(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryUpdatedAtConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryUpdatedAtConditionCall) DoAndReturn(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryUpdatedAtConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UserAgentColumns mocks base method. +func (m *MockSessionRepository) UserAgentColumns() domain.SessionUserAgentColumns { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UserAgentColumns") + ret0, _ := ret[0].(domain.SessionUserAgentColumns) + return ret0 +} + +// UserAgentColumns indicates an expected call of UserAgentColumns. +func (mr *MockSessionRepositoryMockRecorder) UserAgentColumns() *MockSessionRepositoryUserAgentColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserAgentColumns", reflect.TypeOf((*MockSessionRepository)(nil).UserAgentColumns)) + return &MockSessionRepositoryUserAgentColumnsCall{Call: call} +} + +// MockSessionRepositoryUserAgentColumnsCall wrap *gomock.Call +type MockSessionRepositoryUserAgentColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryUserAgentColumnsCall) Return(arg0 domain.SessionUserAgentColumns) *MockSessionRepositoryUserAgentColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryUserAgentColumnsCall) Do(f func() domain.SessionUserAgentColumns) *MockSessionRepositoryUserAgentColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryUserAgentColumnsCall) DoAndReturn(f func() domain.SessionUserAgentColumns) *MockSessionRepositoryUserAgentColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UserAgentConditions mocks base method. +func (m *MockSessionRepository) UserAgentConditions() domain.SessionUserAgentConditions { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UserAgentConditions") + ret0, _ := ret[0].(domain.SessionUserAgentConditions) + return ret0 +} + +// UserAgentConditions indicates an expected call of UserAgentConditions. +func (mr *MockSessionRepositoryMockRecorder) UserAgentConditions() *MockSessionRepositoryUserAgentConditionsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserAgentConditions", reflect.TypeOf((*MockSessionRepository)(nil).UserAgentConditions)) + return &MockSessionRepositoryUserAgentConditionsCall{Call: call} +} + +// MockSessionRepositoryUserAgentConditionsCall wrap *gomock.Call +type MockSessionRepositoryUserAgentConditionsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryUserAgentConditionsCall) Return(arg0 domain.SessionUserAgentConditions) *MockSessionRepositoryUserAgentConditionsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryUserAgentConditionsCall) Do(f func() domain.SessionUserAgentConditions) *MockSessionRepositoryUserAgentConditionsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryUserAgentConditionsCall) DoAndReturn(f func() domain.SessionUserAgentConditions) *MockSessionRepositoryUserAgentConditionsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UserAgentIDCondition mocks base method. +func (m *MockSessionRepository) UserAgentIDCondition(userAgentID string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UserAgentIDCondition", userAgentID) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UserAgentIDCondition indicates an expected call of UserAgentIDCondition. +func (mr *MockSessionRepositoryMockRecorder) UserAgentIDCondition(userAgentID any) *MockSessionRepositoryUserAgentIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserAgentIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserAgentIDCondition), userAgentID) + return &MockSessionRepositoryUserAgentIDConditionCall{Call: call} +} + +// MockSessionRepositoryUserAgentIDConditionCall wrap *gomock.Call +type MockSessionRepositoryUserAgentIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryUserAgentIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryUserAgentIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryUserAgentIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryUserAgentIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryUserAgentIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryUserAgentIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UserIDColumn mocks base method. +func (m *MockSessionRepository) UserIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UserIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UserIDColumn indicates an expected call of UserIDColumn. +func (mr *MockSessionRepositoryMockRecorder) UserIDColumn() *MockSessionRepositoryUserIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDColumn", reflect.TypeOf((*MockSessionRepository)(nil).UserIDColumn)) + return &MockSessionRepositoryUserIDColumnCall{Call: call} +} + +// MockSessionRepositoryUserIDColumnCall wrap *gomock.Call +type MockSessionRepositoryUserIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryUserIDColumnCall) Return(arg0 database.Column) *MockSessionRepositoryUserIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryUserIDColumnCall) Do(f func() database.Column) *MockSessionRepositoryUserIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryUserIDColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryUserIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UserIDCondition mocks base method. +func (m *MockSessionRepository) UserIDCondition(userID string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UserIDCondition", userID) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UserIDCondition indicates an expected call of UserIDCondition. +func (mr *MockSessionRepositoryMockRecorder) UserIDCondition(userID any) *MockSessionRepositoryUserIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserIDCondition), userID) + return &MockSessionRepositoryUserIDConditionCall{Call: call} +} + +// MockSessionRepositoryUserIDConditionCall wrap *gomock.Call +type MockSessionRepositoryUserIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSessionRepositoryUserIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryUserIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSessionRepositoryUserIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryUserIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSessionRepositoryUserIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryUserIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/user.mock.go b/backend/v3/domain/mock/user.mock.go new file mode 100644 index 000000000..d83a1372a --- /dev/null +++ b/backend/v3/domain/mock/user.mock.go @@ -0,0 +1,1321 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: UserRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/user.mock.go . UserRepository +// + +// 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" +) + +// MockUserRepository is a mock of UserRepository interface. +type MockUserRepository struct { + ctrl *gomock.Controller + recorder *MockUserRepositoryMockRecorder + isgomock struct{} +} + +// MockUserRepositoryMockRecorder is the mock recorder for MockUserRepository. +type MockUserRepositoryMockRecorder struct { + mock *MockUserRepository +} + +// NewMockUserRepository creates a new mock instance. +func NewMockUserRepository(ctrl *gomock.Controller) *MockUserRepository { + mock := &MockUserRepository{ctrl: ctrl} + mock.recorder = &MockUserRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockUserRepository) EXPECT() *MockUserRepositoryMockRecorder { + return m.recorder +} + +// AddMetadata mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) AddMetadata(metadata ...any) *MockUserRepositoryAddMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMetadata", reflect.TypeOf((*MockUserRepository)(nil).AddMetadata), metadata...) + return &MockUserRepositoryAddMetadataCall{Call: call} +} + +// MockUserRepositoryAddMetadataCall wrap *gomock.Call +type MockUserRepositoryAddMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryAddMetadataCall) Return(arg0 database.Change) *MockUserRepositoryAddMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryAddMetadataCall) Do(f func(...*domain.Metadata) database.Change) *MockUserRepositoryAddMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryAddMetadataCall) DoAndReturn(f func(...*domain.Metadata) database.Change) *MockUserRepositoryAddMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Create mocks base method. +func (m *MockUserRepository) Create(ctx context.Context, client database.QueryExecutor, user *domain.User) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", ctx, client, user) + ret0, _ := ret[0].(error) + return ret0 +} + +// Create indicates an expected call of Create. +func (mr *MockUserRepositoryMockRecorder) Create(ctx, client, user any) *MockUserRepositoryCreateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockUserRepository)(nil).Create), ctx, client, user) + return &MockUserRepositoryCreateCall{Call: call} +} + +// MockUserRepositoryCreateCall wrap *gomock.Call +type MockUserRepositoryCreateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryCreateCall) Return(arg0 error) *MockUserRepositoryCreateCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryCreateCall) Do(f func(context.Context, database.QueryExecutor, *domain.User) error) *MockUserRepositoryCreateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryCreateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.User) error) *MockUserRepositoryCreateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreatedAtColumn mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) CreatedAtColumn() *MockUserRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockUserRepository)(nil).CreatedAtColumn)) + return &MockUserRepositoryCreatedAtColumnCall{Call: call} +} + +// MockUserRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockUserRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockUserRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockUserRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockUserRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockUserRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockUserRepositoryMockRecorder) Delete(ctx, client, condition any) *MockUserRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockUserRepository)(nil).Delete), ctx, client, condition) + return &MockUserRepositoryDeleteCall{Call: call} +} + +// MockUserRepositoryDeleteCall wrap *gomock.Call +type MockUserRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockUserRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockUserRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockUserRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ExistsMetadata mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) ExistsMetadata(condition any) *MockUserRepositoryExistsMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsMetadata", reflect.TypeOf((*MockUserRepository)(nil).ExistsMetadata), condition) + return &MockUserRepositoryExistsMetadataCall{Call: call} +} + +// MockUserRepositoryExistsMetadataCall wrap *gomock.Call +type MockUserRepositoryExistsMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryExistsMetadataCall) Return(arg0 database.Condition) *MockUserRepositoryExistsMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryExistsMetadataCall) Do(f func(database.Condition) database.Condition) *MockUserRepositoryExistsMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryExistsMetadataCall) DoAndReturn(f func(database.Condition) database.Condition) *MockUserRepositoryExistsMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockUserRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.User, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockUserRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockUserRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockUserRepository)(nil).Get), varargs...) + return &MockUserRepositoryGetCall{Call: call} +} + +// MockUserRepositoryGetCall wrap *gomock.Call +type MockUserRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryGetCall) Return(arg0 *domain.User, arg1 error) *MockUserRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.User, error)) *MockUserRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.User, error)) *MockUserRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Human mocks base method. +func (m *MockUserRepository) Human() domain.HumanUserRepository { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Human") + ret0, _ := ret[0].(domain.HumanUserRepository) + return ret0 +} + +// Human indicates an expected call of Human. +func (mr *MockUserRepositoryMockRecorder) Human() *MockUserRepositoryHumanCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Human", reflect.TypeOf((*MockUserRepository)(nil).Human)) + return &MockUserRepositoryHumanCall{Call: call} +} + +// MockUserRepositoryHumanCall wrap *gomock.Call +type MockUserRepositoryHumanCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryHumanCall) Return(arg0 domain.HumanUserRepository) *MockUserRepositoryHumanCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryHumanCall) Do(f func() domain.HumanUserRepository) *MockUserRepositoryHumanCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryHumanCall) DoAndReturn(f func() domain.HumanUserRepository) *MockUserRepositoryHumanCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) IDCondition(userID any) *MockUserRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockUserRepository)(nil).IDCondition), userID) + return &MockUserRepositoryIDConditionCall{Call: call} +} + +// MockUserRepositoryIDConditionCall wrap *gomock.Call +type MockUserRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryIDConditionCall) Return(arg0 database.Condition) *MockUserRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockUserRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockUserRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockUserRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockUserRepository)(nil).InstanceIDCondition), instanceID) + return &MockUserRepositoryInstanceIDConditionCall{Call: call} +} + +// MockUserRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockUserRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockUserRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockUserRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockUserRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockUserRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.User, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockUserRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockUserRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockUserRepository)(nil).List), varargs...) + return &MockUserRepositoryListCall{Call: call} +} + +// MockUserRepositoryListCall wrap *gomock.Call +type MockUserRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryListCall) Return(arg0 []*domain.User, arg1 error) *MockUserRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.User, error)) *MockUserRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.User, error)) *MockUserRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadIdentityProviderLinks mocks base method. +func (m *MockUserRepository) LoadIdentityProviderLinks() domain.UserRepository { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadIdentityProviderLinks") + ret0, _ := ret[0].(domain.UserRepository) + return ret0 +} + +// LoadIdentityProviderLinks indicates an expected call of LoadIdentityProviderLinks. +func (mr *MockUserRepositoryMockRecorder) LoadIdentityProviderLinks() *MockUserRepositoryLoadIdentityProviderLinksCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadIdentityProviderLinks", reflect.TypeOf((*MockUserRepository)(nil).LoadIdentityProviderLinks)) + return &MockUserRepositoryLoadIdentityProviderLinksCall{Call: call} +} + +// MockUserRepositoryLoadIdentityProviderLinksCall wrap *gomock.Call +type MockUserRepositoryLoadIdentityProviderLinksCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryLoadIdentityProviderLinksCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadIdentityProviderLinksCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryLoadIdentityProviderLinksCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadIdentityProviderLinksCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryLoadIdentityProviderLinksCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadIdentityProviderLinksCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadKeys mocks base method. +func (m *MockUserRepository) LoadKeys() domain.UserRepository { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadKeys") + ret0, _ := ret[0].(domain.UserRepository) + return ret0 +} + +// LoadKeys indicates an expected call of LoadKeys. +func (mr *MockUserRepositoryMockRecorder) LoadKeys() *MockUserRepositoryLoadKeysCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKeys", reflect.TypeOf((*MockUserRepository)(nil).LoadKeys)) + return &MockUserRepositoryLoadKeysCall{Call: call} +} + +// MockUserRepositoryLoadKeysCall wrap *gomock.Call +type MockUserRepositoryLoadKeysCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryLoadKeysCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadKeysCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryLoadKeysCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadKeysCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryLoadKeysCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadKeysCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadMetadata mocks base method. +func (m *MockUserRepository) LoadMetadata() domain.UserRepository { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadMetadata") + ret0, _ := ret[0].(domain.UserRepository) + return ret0 +} + +// LoadMetadata indicates an expected call of LoadMetadata. +func (mr *MockUserRepositoryMockRecorder) LoadMetadata() *MockUserRepositoryLoadMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMetadata", reflect.TypeOf((*MockUserRepository)(nil).LoadMetadata)) + return &MockUserRepositoryLoadMetadataCall{Call: call} +} + +// MockUserRepositoryLoadMetadataCall wrap *gomock.Call +type MockUserRepositoryLoadMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryLoadMetadataCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryLoadMetadataCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryLoadMetadataCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadPATs mocks base method. +func (m *MockUserRepository) LoadPATs() domain.UserRepository { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadPATs") + ret0, _ := ret[0].(domain.UserRepository) + return ret0 +} + +// LoadPATs indicates an expected call of LoadPATs. +func (mr *MockUserRepositoryMockRecorder) LoadPATs() *MockUserRepositoryLoadPATsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadPATs", reflect.TypeOf((*MockUserRepository)(nil).LoadPATs)) + return &MockUserRepositoryLoadPATsCall{Call: call} +} + +// MockUserRepositoryLoadPATsCall wrap *gomock.Call +type MockUserRepositoryLoadPATsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryLoadPATsCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadPATsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryLoadPATsCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadPATsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryLoadPATsCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadPATsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadPasskeys mocks base method. +func (m *MockUserRepository) LoadPasskeys() domain.UserRepository { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadPasskeys") + ret0, _ := ret[0].(domain.UserRepository) + return ret0 +} + +// LoadPasskeys indicates an expected call of LoadPasskeys. +func (mr *MockUserRepositoryMockRecorder) LoadPasskeys() *MockUserRepositoryLoadPasskeysCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadPasskeys", reflect.TypeOf((*MockUserRepository)(nil).LoadPasskeys)) + return &MockUserRepositoryLoadPasskeysCall{Call: call} +} + +// MockUserRepositoryLoadPasskeysCall wrap *gomock.Call +type MockUserRepositoryLoadPasskeysCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryLoadPasskeysCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadPasskeysCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryLoadPasskeysCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadPasskeysCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryLoadPasskeysCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadPasskeysCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadVerifications mocks base method. +func (m *MockUserRepository) LoadVerifications() domain.UserRepository { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadVerifications") + ret0, _ := ret[0].(domain.UserRepository) + return ret0 +} + +// LoadVerifications indicates an expected call of LoadVerifications. +func (mr *MockUserRepositoryMockRecorder) LoadVerifications() *MockUserRepositoryLoadVerificationsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadVerifications", reflect.TypeOf((*MockUserRepository)(nil).LoadVerifications)) + return &MockUserRepositoryLoadVerificationsCall{Call: call} +} + +// MockUserRepositoryLoadVerificationsCall wrap *gomock.Call +type MockUserRepositoryLoadVerificationsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryLoadVerificationsCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadVerificationsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryLoadVerificationsCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadVerificationsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryLoadVerificationsCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadVerificationsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoginNameCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) LoginNameCondition(op, loginName any) *MockUserRepositoryLoginNameConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoginNameCondition", reflect.TypeOf((*MockUserRepository)(nil).LoginNameCondition), op, loginName) + return &MockUserRepositoryLoginNameConditionCall{Call: call} +} + +// MockUserRepositoryLoginNameConditionCall wrap *gomock.Call +type MockUserRepositoryLoginNameConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryLoginNameConditionCall) Return(arg0 database.Condition) *MockUserRepositoryLoginNameConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryLoginNameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserRepositoryLoginNameConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryLoginNameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserRepositoryLoginNameConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Machine mocks base method. +func (m *MockUserRepository) Machine() domain.MachineUserRepository { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Machine") + ret0, _ := ret[0].(domain.MachineUserRepository) + return ret0 +} + +// Machine indicates an expected call of Machine. +func (mr *MockUserRepositoryMockRecorder) Machine() *MockUserRepositoryMachineCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Machine", reflect.TypeOf((*MockUserRepository)(nil).Machine)) + return &MockUserRepositoryMachineCall{Call: call} +} + +// MockUserRepositoryMachineCall wrap *gomock.Call +type MockUserRepositoryMachineCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryMachineCall) Return(arg0 domain.MachineUserRepository) *MockUserRepositoryMachineCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryMachineCall) Do(f func() domain.MachineUserRepository) *MockUserRepositoryMachineCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryMachineCall) DoAndReturn(f func() domain.MachineUserRepository) *MockUserRepositoryMachineCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MetadataKeyCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) MetadataKeyCondition(key any) *MockUserRepositoryMetadataKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataKeyCondition", reflect.TypeOf((*MockUserRepository)(nil).MetadataKeyCondition), key) + return &MockUserRepositoryMetadataKeyConditionCall{Call: call} +} + +// MockUserRepositoryMetadataKeyConditionCall wrap *gomock.Call +type MockUserRepositoryMetadataKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryMetadataKeyConditionCall) Return(arg0 database.Condition) *MockUserRepositoryMetadataKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryMetadataKeyConditionCall) Do(f func(string) database.Condition) *MockUserRepositoryMetadataKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryMetadataKeyConditionCall) DoAndReturn(f func(string) database.Condition) *MockUserRepositoryMetadataKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MetadataValueCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) MetadataValueCondition(op, value any) *MockUserRepositoryMetadataValueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataValueCondition", reflect.TypeOf((*MockUserRepository)(nil).MetadataValueCondition), op, value) + return &MockUserRepositoryMetadataValueConditionCall{Call: call} +} + +// MockUserRepositoryMetadataValueConditionCall wrap *gomock.Call +type MockUserRepositoryMetadataValueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryMetadataValueConditionCall) Return(arg0 database.Condition) *MockUserRepositoryMetadataValueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryMetadataValueConditionCall) Do(f func(database.BytesOperation, []byte) database.Condition) *MockUserRepositoryMetadataValueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryMetadataValueConditionCall) DoAndReturn(f func(database.BytesOperation, []byte) database.Condition) *MockUserRepositoryMetadataValueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrgIDCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) OrgIDCondition(orgID any) *MockUserRepositoryOrgIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrgIDCondition", reflect.TypeOf((*MockUserRepository)(nil).OrgIDCondition), orgID) + return &MockUserRepositoryOrgIDConditionCall{Call: call} +} + +// MockUserRepositoryOrgIDConditionCall wrap *gomock.Call +type MockUserRepositoryOrgIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryOrgIDConditionCall) Return(arg0 database.Condition) *MockUserRepositoryOrgIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryOrgIDConditionCall) Do(f func(string) database.Condition) *MockUserRepositoryOrgIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryOrgIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockUserRepositoryOrgIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) PrimaryKeyColumns() *MockUserRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockUserRepository)(nil).PrimaryKeyColumns)) + return &MockUserRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockUserRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockUserRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockUserRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockUserRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockUserRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) PrimaryKeyCondition(instanceID, userID any) *MockUserRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockUserRepository)(nil).PrimaryKeyCondition), instanceID, userID) + return &MockUserRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockUserRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockUserRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockUserRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockUserRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockUserRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveMetadata mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) RemoveMetadata(condition any) *MockUserRepositoryRemoveMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMetadata", reflect.TypeOf((*MockUserRepository)(nil).RemoveMetadata), condition) + return &MockUserRepositoryRemoveMetadataCall{Call: call} +} + +// MockUserRepositoryRemoveMetadataCall wrap *gomock.Call +type MockUserRepositoryRemoveMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryRemoveMetadataCall) Return(arg0 database.Change) *MockUserRepositoryRemoveMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryRemoveMetadataCall) Do(f func(database.Condition) database.Change) *MockUserRepositoryRemoveMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryRemoveMetadataCall) DoAndReturn(f func(database.Condition) database.Change) *MockUserRepositoryRemoveMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetState mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) SetState(state any) *MockUserRepositorySetStateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockUserRepository)(nil).SetState), state) + return &MockUserRepositorySetStateCall{Call: call} +} + +// MockUserRepositorySetStateCall wrap *gomock.Call +type MockUserRepositorySetStateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositorySetStateCall) Return(arg0 database.Change) *MockUserRepositorySetStateCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositorySetStateCall) Do(f func(domain.UserState) database.Change) *MockUserRepositorySetStateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositorySetStateCall) DoAndReturn(f func(domain.UserState) database.Change) *MockUserRepositorySetStateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockUserRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockUserRepository)(nil).SetUpdatedAt), updatedAt) + return &MockUserRepositorySetUpdatedAtCall{Call: call} +} + +// MockUserRepositorySetUpdatedAtCall wrap *gomock.Call +type MockUserRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockUserRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositorySetUpdatedAtCall) Do(f func(time.Time) database.Change) *MockUserRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockUserRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUsername mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) SetUsername(username any) *MockUserRepositorySetUsernameCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUsername", reflect.TypeOf((*MockUserRepository)(nil).SetUsername), username) + return &MockUserRepositorySetUsernameCall{Call: call} +} + +// MockUserRepositorySetUsernameCall wrap *gomock.Call +type MockUserRepositorySetUsernameCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositorySetUsernameCall) Return(arg0 database.Change) *MockUserRepositorySetUsernameCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositorySetUsernameCall) Do(f func(string) database.Change) *MockUserRepositorySetUsernameCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositorySetUsernameCall) DoAndReturn(f func(string) database.Change) *MockUserRepositorySetUsernameCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) StateColumn() *MockUserRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockUserRepository)(nil).StateColumn)) + return &MockUserRepositoryStateColumnCall{Call: call} +} + +// MockUserRepositoryStateColumnCall wrap *gomock.Call +type MockUserRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryStateColumnCall) Return(arg0 database.Column) *MockUserRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryStateColumnCall) Do(f func() database.Column) *MockUserRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockUserRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) StateCondition(state any) *MockUserRepositoryStateConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockUserRepository)(nil).StateCondition), state) + return &MockUserRepositoryStateConditionCall{Call: call} +} + +// MockUserRepositoryStateConditionCall wrap *gomock.Call +type MockUserRepositoryStateConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryStateConditionCall) Return(arg0 database.Condition) *MockUserRepositoryStateConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryStateConditionCall) Do(f func(domain.UserState) database.Condition) *MockUserRepositoryStateConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryStateConditionCall) DoAndReturn(f func(domain.UserState) database.Condition) *MockUserRepositoryStateConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) TypeCondition(userType any) *MockUserRepositoryTypeConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockUserRepository)(nil).TypeCondition), userType) + return &MockUserRepositoryTypeConditionCall{Call: call} +} + +// MockUserRepositoryTypeConditionCall wrap *gomock.Call +type MockUserRepositoryTypeConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockUserRepositoryTypeConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryTypeConditionCall) Do(f func(domain.UserType) database.Condition) *MockUserRepositoryTypeConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryTypeConditionCall) DoAndReturn(f func(domain.UserType) database.Condition) *MockUserRepositoryTypeConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Update mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockUserRepositoryUpdateCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client, condition}, changes...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserRepository)(nil).Update), varargs...) + return &MockUserRepositoryUpdateCall{Call: call} +} + +// MockUserRepositoryUpdateCall wrap *gomock.Call +type MockUserRepositoryUpdateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryUpdateCall) Return(arg0 int64, arg1 error) *MockUserRepositoryUpdateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryUpdateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockUserRepositoryUpdateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryUpdateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockUserRepositoryUpdateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UsernameColumn mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) UsernameColumn() *MockUserRepositoryUsernameColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsernameColumn", reflect.TypeOf((*MockUserRepository)(nil).UsernameColumn)) + return &MockUserRepositoryUsernameColumnCall{Call: call} +} + +// MockUserRepositoryUsernameColumnCall wrap *gomock.Call +type MockUserRepositoryUsernameColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryUsernameColumnCall) Return(arg0 database.Column) *MockUserRepositoryUsernameColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryUsernameColumnCall) Do(f func() database.Column) *MockUserRepositoryUsernameColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryUsernameColumnCall) DoAndReturn(f func() database.Column) *MockUserRepositoryUsernameColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UsernameCondition mocks base method. +func (m *MockUserRepository) 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 *MockUserRepositoryMockRecorder) UsernameCondition(op, username any) *MockUserRepositoryUsernameConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsernameCondition", reflect.TypeOf((*MockUserRepository)(nil).UsernameCondition), op, username) + return &MockUserRepositoryUsernameConditionCall{Call: call} +} + +// MockUserRepositoryUsernameConditionCall wrap *gomock.Call +type MockUserRepositoryUsernameConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockUserRepositoryUsernameConditionCall) Return(arg0 database.Condition) *MockUserRepositoryUsernameConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockUserRepositoryUsernameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserRepositoryUsernameConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockUserRepositoryUsernameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserRepositoryUsernameConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/passkeytype_enumer.go b/backend/v3/domain/passkeytype_enumer.go new file mode 100644 index 000000000..7df4950ef --- /dev/null +++ b/backend/v3/domain/passkeytype_enumer.go @@ -0,0 +1,82 @@ +// Code generated by "enumer -type PasskeyType -transform lower -trimprefix PasskeyType"; DO NOT EDIT. + +package domain + +import ( + "fmt" + "strings" +) + +const _PasskeyTypeName = "unspecifiedpasswordlessu2f" + +var _PasskeyTypeIndex = [...]uint8{0, 11, 23, 26} + +const _PasskeyTypeLowerName = "unspecifiedpasswordlessu2f" + +func (i PasskeyType) String() string { + if i >= PasskeyType(len(_PasskeyTypeIndex)-1) { + return fmt.Sprintf("PasskeyType(%d)", i) + } + return _PasskeyTypeName[_PasskeyTypeIndex[i]:_PasskeyTypeIndex[i+1]] +} + +// An "invalid array index" compiler error signifies that the constant values have changed. +// Re-run the stringer command to generate them again. +func _PasskeyTypeNoOp() { + var x [1]struct{} + _ = x[PasskeyTypeUnspecified-(0)] + _ = x[PasskeyTypePasswordless-(1)] + _ = x[PasskeyTypeU2F-(2)] +} + +var _PasskeyTypeValues = []PasskeyType{PasskeyTypeUnspecified, PasskeyTypePasswordless, PasskeyTypeU2F} + +var _PasskeyTypeNameToValueMap = map[string]PasskeyType{ + _PasskeyTypeName[0:11]: PasskeyTypeUnspecified, + _PasskeyTypeLowerName[0:11]: PasskeyTypeUnspecified, + _PasskeyTypeName[11:23]: PasskeyTypePasswordless, + _PasskeyTypeLowerName[11:23]: PasskeyTypePasswordless, + _PasskeyTypeName[23:26]: PasskeyTypeU2F, + _PasskeyTypeLowerName[23:26]: PasskeyTypeU2F, +} + +var _PasskeyTypeNames = []string{ + _PasskeyTypeName[0:11], + _PasskeyTypeName[11:23], + _PasskeyTypeName[23:26], +} + +// PasskeyTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func PasskeyTypeString(s string) (PasskeyType, error) { + if val, ok := _PasskeyTypeNameToValueMap[s]; ok { + return val, nil + } + + if val, ok := _PasskeyTypeNameToValueMap[strings.ToLower(s)]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to PasskeyType values", s) +} + +// PasskeyTypeValues returns all values of the enum +func PasskeyTypeValues() []PasskeyType { + return _PasskeyTypeValues +} + +// PasskeyTypeStrings returns a slice of all String values of the enum +func PasskeyTypeStrings() []string { + strs := make([]string, len(_PasskeyTypeNames)) + copy(strs, _PasskeyTypeNames) + return strs +} + +// IsAPasskeyType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i PasskeyType) IsAPasskeyType() bool { + for _, v := range _PasskeyTypeValues { + if i == v { + return true + } + } + return false +} diff --git a/backend/v3/domain/personalaccesstokentype_enumer.go b/backend/v3/domain/personalaccesstokentype_enumer.go new file mode 100644 index 000000000..b31ee5db7 --- /dev/null +++ b/backend/v3/domain/personalaccesstokentype_enumer.go @@ -0,0 +1,82 @@ +// Code generated by "enumer -type PersonalAccessTokenType -transform lower -trimprefix PersonalAccessTokenType"; DO NOT EDIT. + +package domain + +import ( + "fmt" + "strings" +) + +const _PersonalAccessTokenTypeName = "unspecifiedbearerjwt" + +var _PersonalAccessTokenTypeIndex = [...]uint8{0, 11, 17, 20} + +const _PersonalAccessTokenTypeLowerName = "unspecifiedbearerjwt" + +func (i PersonalAccessTokenType) String() string { + if i >= PersonalAccessTokenType(len(_PersonalAccessTokenTypeIndex)-1) { + return fmt.Sprintf("PersonalAccessTokenType(%d)", i) + } + return _PersonalAccessTokenTypeName[_PersonalAccessTokenTypeIndex[i]:_PersonalAccessTokenTypeIndex[i+1]] +} + +// An "invalid array index" compiler error signifies that the constant values have changed. +// Re-run the stringer command to generate them again. +func _PersonalAccessTokenTypeNoOp() { + var x [1]struct{} + _ = x[PersonalAccessTokenTypeUnspecified-(0)] + _ = x[PersonalAccessTokenTypeBearer-(1)] + _ = x[PersonalAccessTokenTypeJWT-(2)] +} + +var _PersonalAccessTokenTypeValues = []PersonalAccessTokenType{PersonalAccessTokenTypeUnspecified, PersonalAccessTokenTypeBearer, PersonalAccessTokenTypeJWT} + +var _PersonalAccessTokenTypeNameToValueMap = map[string]PersonalAccessTokenType{ + _PersonalAccessTokenTypeName[0:11]: PersonalAccessTokenTypeUnspecified, + _PersonalAccessTokenTypeLowerName[0:11]: PersonalAccessTokenTypeUnspecified, + _PersonalAccessTokenTypeName[11:17]: PersonalAccessTokenTypeBearer, + _PersonalAccessTokenTypeLowerName[11:17]: PersonalAccessTokenTypeBearer, + _PersonalAccessTokenTypeName[17:20]: PersonalAccessTokenTypeJWT, + _PersonalAccessTokenTypeLowerName[17:20]: PersonalAccessTokenTypeJWT, +} + +var _PersonalAccessTokenTypeNames = []string{ + _PersonalAccessTokenTypeName[0:11], + _PersonalAccessTokenTypeName[11:17], + _PersonalAccessTokenTypeName[17:20], +} + +// PersonalAccessTokenTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func PersonalAccessTokenTypeString(s string) (PersonalAccessTokenType, error) { + if val, ok := _PersonalAccessTokenTypeNameToValueMap[s]; ok { + return val, nil + } + + if val, ok := _PersonalAccessTokenTypeNameToValueMap[strings.ToLower(s)]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to PersonalAccessTokenType values", s) +} + +// PersonalAccessTokenTypeValues returns all values of the enum +func PersonalAccessTokenTypeValues() []PersonalAccessTokenType { + return _PersonalAccessTokenTypeValues +} + +// PersonalAccessTokenTypeStrings returns a slice of all String values of the enum +func PersonalAccessTokenTypeStrings() []string { + strs := make([]string, len(_PersonalAccessTokenTypeNames)) + copy(strs, _PersonalAccessTokenTypeNames) + return strs +} + +// IsAPersonalAccessTokenType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i PersonalAccessTokenType) IsAPersonalAccessTokenType() bool { + for _, v := range _PersonalAccessTokenTypeValues { + if i == v { + return true + } + } + return false +} diff --git a/backend/v3/domain/session.go b/backend/v3/domain/session.go index 5dfb459a4..0f71216e3 100644 --- a/backend/v3/domain/session.go +++ b/backend/v3/domain/session.go @@ -64,11 +64,11 @@ type sessionColumns interface { UpdatedAtColumn() database.Column // FactorColumns returns the columns for the factors fields. - FactorColumns() sessionFactorColumns + FactorColumns() SessionFactorColumns // MetadataColumns returns the columns for the metadata fields. - MetadataColumns() sessionMetadataColumns + MetadataColumns() SessionMetadataColumns // UserAgentColumns returns the columns for the user agent fields. - UserAgentColumns() sessionUserAgentColumns + UserAgentColumns() SessionUserAgentColumns } // sessionConditions define all the conditions for the session table. @@ -89,11 +89,11 @@ type sessionConditions interface { UpdatedAtCondition(op database.NumberOperation, updatedAt time.Time) database.Condition // FactorConditions returns the conditions for the factors fields. - FactorConditions() sessionFactorConditions + FactorConditions() SessionFactorConditions // MetadataConditions returns the conditions for the metadata fields. - MetadataConditions() sessionMetadataConditions + MetadataConditions() SessionMetadataConditions // UserAgentConditions returns the conditions for the user agent fields. - UserAgentConditions() sessionUserAgentConditions + UserAgentConditions() SessionUserAgentConditions } type sessionChanges interface { diff --git a/backend/v3/domain/session_factor.go b/backend/v3/domain/session_factor.go index 76b408621..7df3666da 100644 --- a/backend/v3/domain/session_factor.go +++ b/backend/v3/domain/session_factor.go @@ -225,7 +225,7 @@ func GetChallenge[T SessionChallenge](challenges SessionChallenges) (T, bool) { return nilT, false } -type sessionFactorColumns interface { +type SessionFactorColumns interface { // InstanceIDColumn returns the column for the instance id field. InstanceIDColumn() database.Column // SessionIDColumn returns the column for the session id field. @@ -240,7 +240,7 @@ type sessionFactorColumns interface { LastVerifiedAtColumn() database.Column } -type sessionFactorConditions interface { +type SessionFactorConditions interface { // PrimaryKeyCondition returns a filter on the primary key fields. PrimaryKeyCondition(instanceID, sessionID string, factorType SessionFactorType) database.Condition // InstanceIDCondition returns an equal filter on the instance id field. diff --git a/backend/v3/domain/session_metadata.go b/backend/v3/domain/session_metadata.go index 107f37605..80782a587 100644 --- a/backend/v3/domain/session_metadata.go +++ b/backend/v3/domain/session_metadata.go @@ -7,13 +7,13 @@ type SessionMetadata struct { SessionID string `json:"sessionId,omitempty" db:"session_id"` } -type sessionMetadataColumns interface { +type SessionMetadataColumns interface { MetadataColumns // SessionIDColumn returns the column for the session id field. SessionIDColumn() database.Column } -type sessionMetadataConditions interface { +type SessionMetadataConditions interface { MetadataConditions // PrimaryKeyCondition returns a filter on the primary key fields. PrimaryKeyCondition(instanceID, sessionID, key string) database.Condition diff --git a/backend/v3/domain/session_user_agent.go b/backend/v3/domain/session_user_agent.go index 7216438bf..97fd900b2 100644 --- a/backend/v3/domain/session_user_agent.go +++ b/backend/v3/domain/session_user_agent.go @@ -15,7 +15,7 @@ type SessionUserAgent struct { Header http.Header `json:"header,omitempty" db:"headers"` } -type sessionUserAgentColumns interface { +type SessionUserAgentColumns interface { // InstanceIDColumn returns the column for the instance id field. InstanceIDColumn() database.Column // FingerprintIDColumn returns the column for the fingerprint id field. @@ -28,7 +28,7 @@ type sessionUserAgentColumns interface { HeadersColumn() database.Column } -type sessionUserAgentConditions interface { +type SessionUserAgentConditions interface { // PrimaryKeyCondition returns a filter on the primary key fields. PrimaryKeyCondition(instanceID, fingerprintID string) database.Condition // InstanceIDCondition returns an equal filter on the instance id field. diff --git a/backend/v3/domain/user.go b/backend/v3/domain/user.go index cb6527577..2417e3822 100644 --- a/backend/v3/domain/user.go +++ b/backend/v3/domain/user.go @@ -1,245 +1,223 @@ package domain import ( - "context" "time" - "github.com/zitadel/zitadel/backend/v3/storage/database" -) - -// userColumns define all the columns of the user table. -type userColumns interface { - // InstanceIDColumn returns the column for the instance id field. - InstanceIDColumn() database.Column - // OrgIDColumn returns the column for the org id field. - OrgIDColumn() database.Column - // IDColumn returns the column for the id field. - IDColumn() database.Column - // UsernameColumn returns the column for the username field. - UsernameColumn() database.Column - // CreatedAtColumn returns the column for the created at field. - CreatedAtColumn() database.Column - // UpdatedAtColumn returns the column for the updated at field. - UpdatedAtColumn() database.Column - // DeletedAtColumn returns the column for the deleted at field. - DeletedAtColumn() database.Column -} - -// userConditions define all the conditions for the user table. -type userConditions interface { - // PrimaryKeyCondition returns a filter on the primary key fields. - PrimaryKeyCondition(instanceID, userID string) database.Condition - // InstanceIDCondition returns an equal filter on the instance id field. - InstanceIDCondition(instanceID string) database.Condition - // OrgIDCondition returns an equal filter on the org id field. - OrgIDCondition(orgID string) database.Condition - // IDCondition returns an equal filter on the id field. - IDCondition(userID string) database.Condition - // UsernameCondition returns a filter on the username field. - UsernameCondition(op database.TextOperation, username string) database.Condition - // CreatedAtCondition returns a filter on the created at field. - CreatedAtCondition(op database.NumberOperation, createdAt time.Time) database.Condition - // UpdatedAtCondition returns a filter on the updated at field. - UpdatedAtCondition(op database.NumberOperation, updatedAt time.Time) database.Condition - // DeletedAtCondition filters for deleted users is isDeleted is set to true otherwise only not deleted users must be filtered. - DeletedCondition(isDeleted bool) database.Condition - // DeletedAtCondition filters for deleted users based on the given parameters. - DeletedAtCondition(op database.NumberOperation, deletedAt time.Time) database.Condition -} - -// userChanges define all the changes for the user table. -type userChanges interface { - // SetUsername sets the username column. - SetUsername(username string) database.Change -} - -// UserRepository is the interface for the user repository. -type UserRepository interface { - Repository - - userColumns - userConditions - userChanges - // Get returns a user based on the given condition. - Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*User, error) - // List returns a list of users based on the given condition. - List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*User, error) - // Create creates a new user. - Create(ctx context.Context, client database.QueryExecutor, user *User) error - // Delete removes users based on the given condition. - Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) error - // Human returns the [HumanRepository]. - Human() HumanRepository - // Machine returns the [MachineRepository]. - Machine() MachineRepository -} - -// humanColumns define all the columns of the human table which inherits the user table. -type humanColumns interface { - userColumns - // FirstNameColumn returns the column for the first name field. - FirstNameColumn() database.Column - // LastNameColumn returns the column for the last name field. - LastNameColumn() database.Column - // EmailAddressColumn returns the column for the email address field. - EmailAddressColumn() database.Column - // EmailVerifiedAtColumn returns the column for the email verified at field. - EmailVerifiedAtColumn() database.Column - // PhoneNumberColumn returns the column for the phone number field. - PhoneNumberColumn() database.Column - // PhoneVerifiedAtColumn returns the column for the phone verified at field. - PhoneVerifiedAtColumn() database.Column -} - -// humanConditions define all the conditions for the human table which inherits the user table. -type humanConditions interface { - userConditions - // FirstNameCondition returns a filter on the first name field. - FirstNameCondition(op database.TextOperation, firstName string) database.Condition - // LastNameCondition returns a filter on the last name field. - LastNameCondition(op database.TextOperation, lastName string) database.Condition - // EmailAddressCondition returns a filter on the email address field. - EmailAddressCondition(op database.TextOperation, email string) database.Condition - // EmailVerifiedCondition returns a filter that checks if the email is verified or not. - EmailVerifiedCondition(isVerified bool) database.Condition - // EmailVerifiedAtCondition returns a filter on the email verified at field. - EmailVerifiedAtCondition(op database.NumberOperation, emailVerifiedAt time.Time) database.Condition - - // PhoneNumberCondition returns a filter on the phone number field. - PhoneNumberCondition(op database.TextOperation, phoneNumber string) database.Condition - // PhoneVerifiedCondition returns a filter that checks if the phone is verified or not. - PhoneVerifiedCondition(isVerified bool) database.Condition - // PhoneVerifiedAtCondition returns a filter on the phone verified at field. - PhoneVerifiedAtCondition(op database.NumberOperation, phoneVerifiedAt time.Time) database.Condition -} - -// humanChanges define all the changes for the human table which inherits the user table. -type humanChanges interface { - userChanges - // SetFirstName sets the first name field of the human. - SetFirstName(firstName string) database.Change - // SetLastName sets the last name field of the human. - SetLastName(lastName string) database.Change - - // SetEmail sets the email address and verified field of the email - // if verifiedAt is nil the email is not verified - SetEmail(address string, verifiedAt *time.Time) database.Change - // SetEmailAddress sets the email address field of the email - SetEmailAddress(email string) database.Change - // SetEmailVerifiedAt sets the verified column of the email - // if at is zero the statement uses the database timestamp - SetEmailVerifiedAt(at time.Time) database.Change - - // SetPhone sets the phone number and verified field - // if verifiedAt is nil the phone is not verified - SetPhone(number string, verifiedAt *time.Time) database.Change - // SetPhoneNumber sets the phone number field - SetPhoneNumber(phoneNumber string) database.Change - // SetPhoneVerifiedAt sets the verified field of the phone - // if at is zero the statement uses the database timestamp - SetPhoneVerifiedAt(at time.Time) database.Change -} - -// HumanRepository is the interface for the human repository it inherits the user repository. -type HumanRepository interface { - humanColumns - humanConditions - humanChanges - - // Get returns an email based on the given condition. - GetEmail(ctx context.Context, client database.QueryExecutor, condition database.Condition) (*Email, error) - // Update updates human users based on the given condition and changes. - Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) error -} - -// machineColumns define all the columns of the machine table which inherits the user table. -type machineColumns interface { - userColumns - // DescriptionColumn returns the column for the description field. - DescriptionColumn() database.Column -} - -// machineConditions define all the conditions for the machine table which inherits the user table. -type machineConditions interface { - userConditions - // DescriptionCondition returns a filter on the description field. - DescriptionCondition(op database.TextOperation, description string) database.Condition -} - -// machineChanges define all the changes for the machine table which inherits the user table. -type machineChanges interface { - userChanges - // SetDescription sets the description field of the machine. - SetDescription(description string) database.Change -} - -// MachineRepository is the interface for the machine repository it inherits the user repository. -type MachineRepository interface { - // Update updates machine users based on the given condition and changes. - Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) error - - machineColumns - machineConditions - machineChanges -} - -// UserTraits is implemented by [Human] and [Machine]. -type UserTraits interface { - Type() UserType -} - -type UserType string - -const ( - UserTypeHuman UserType = "human" - UserTypeMachine UserType = "machine" + "golang.org/x/text/language" ) type User struct { - InstanceID string - OrgID string - ID string + InstanceID string `json:"instanceId,omitempty" db:"instance_id"` + OrganizationID string `json:"organizationId,omitempty" db:"organization_id"` + ID string `json:"id,omitempty" db:"id"` + Username string `json:"username,omitempty" db:"username"` + State UserState `json:"state,omitempty" db:"state"` + CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"` + UpdatedAt time.Time `json:"updatedAt,omitzero" db:"updated_at"` - CreatedAt time.Time - UpdatedAt time.Time - DeletedAt time.Time - - Username string - - Traits UserTraits + Machine *MachineUser `json:"machine,omitempty" db:"machine"` + Human *HumanUser `json:"human,omitempty" db:"human"` + Metadata []*UserMetadata `json:"metadata,omitempty" db:"metadata"` } -type Human struct { - FirstName string `json:"firstName"` - LastName string `json:"lastName"` - Email *Email `json:"email,omitempty"` - Phone *Phone `json:"phone,omitempty"` +type MachineUser struct { + Name string `json:"name,omitempty" db:"name"` + Description string `json:"description,omitempty" db:"description"` + Secret string `json:"secret,omitempty" db:"secret"` + AccessTokenType PersonalAccessTokenType `json:"access_token_type,omitempty" db:"access_token_type"` + + PATs []*PersonalAccessToken `json:"pats,omitempty" db:"pats"` + Keys []*MachineKey `json:"keys,omitempty" db:"keys"` } -// Type implements [UserTraits]. -func (h *Human) Type() UserType { - return UserTypeHuman +type HumanUser struct { + FirstName string `json:"firstName,omitempty" db:"first_name"` + LastName string `json:"lastName,omitempty" db:"last_name"` + Nickname string `json:"nickname,omitempty" db:"nickname"` + DisplayName string `json:"displayName,omitempty" db:"display_name"` + PreferredLanguage language.Tag `json:"preferredLanguage,omitzero" db:"preferred_language"` + Gender HumanGender `json:"gender,omitempty" db:"gender"` + AvatarKey string `json:"avatarKey,omitempty" db:"avatar_key"` + + MultifactorInitializationSkippedAt time.Time `json:"multifactorInitializationSkippedAt,omitzero" db:"multifactor_initialization_skipped_at"` + + Email HumanEmail `json:"email,omitzero" db:"email"` + Phone *HumanPhone `json:"phone,omitempty" db:"phone"` + Passkeys []*Passkey `json:"passkeys,omitempty" db:"passkeys"` + Password HumanPassword `json:"password,omitzero" db:"password"` + TOTP HumanTOTP `json:"totp,omitzero" db:"totp"` + + IdentityProviderLinks []*IdentityProviderLink `json:"identityProviderLinks,omitempty" db:"identity_provider_links"` + + // Verifications are used if the Login does something on behalf of the user that requires verification + // e.g. starting passkey registration + Verifications []*Verification `db:"verifications" json:"verifications,omitempty"` } -var _ UserTraits = (*Human)(nil) - -type Email struct { - Address string `json:"address"` - VerifiedAt time.Time `json:"verifiedAt"` +type UserMetadata struct { + Metadata + UserID string `json:"userId,omitempty" db:"user_id"` } -type Phone struct { - Number string `json:"number"` - VerifiedAt time.Time `json:"verifiedAt"` +//go:generate enumer -type UserState -transform lower -trimprefix UserState -sql + +type UserState uint8 + +const ( + UserStateUnspecified UserState = iota + UserStateActive + UserStateInactive + UserStateLocked + UserStateInitial +) + +//go:generate enumer -type HumanGender -transform lower -trimprefix HumanGender + +type HumanGender uint8 + +const ( + HumanGenderUnspecified HumanGender = iota + HumanGenderFemale + HumanGenderMale + HumanGenderDiverse +) + +type HumanPassword struct { + // Password is the hashed password + Password string `json:"-" db:"password"` + // IsChangeRequired indicates if the user must change their password + IsChangeRequired bool `json:"isChangeRequired,omitempty" db:"is_change_required"` + // VerifiedAt is the time when the current password was verified + VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"` + // Unverified is the verification data for setting a new password + // If nil, no password change is in progress + Unverified *Verification `json:"-"` + // FailedAttempts is the number of consecutive failed password attempts + // It is reset to 0 on successful verification + FailedAttempts uint8 `json:"failedAttempts,omitempty" db:"failed_attempts"` } -type Machine struct { - Description string `json:"description"` +type HumanEmail struct { + Address string `json:"address" db:"email"` + VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"` + OTP OTP `json:"-"` + // Unverified is the verification data for setting a new email + // If nil, no email change is in progress + Unverified *Verification `json:"-"` } -// Type implements [UserTraits]. -func (m *Machine) Type() UserType { - return UserTypeMachine +type HumanPhone struct { + Number string `json:"number" db:"phone"` + VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"` + OTP OTP `json:"-"` + // Unverified is the verification data for setting a new phone number + // If nil, no phone change is in progress + Unverified *Verification `json:"-"` } -var _ UserTraits = (*Machine)(nil) +type HumanTOTP struct { + VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"` + + LastSuccessfullyCheckedAt time.Time `json:"lastSuccessfullyCheckedAt,omitzero" db:"last_successfully_checked_at"` + // Check is the verified secret + Check *Check `json:"-"` + // Unverified is the unverified secret + Unverified *Verification `json:"-"` +} + +type OTP struct { + EnabledAt time.Time `json:"enabledAt,omitzero" db:"enabled_at"` + LastSuccessfullyCheckedAt time.Time `json:"lastSuccessfullyCheckedAt,omitzero" db:"last_successfully_checked_at"` + // Check is the currently active OTP check + // If nil, no OTP check is active + Check *Check `json:"-"` +} + +type PersonalAccessToken struct { + ID string `json:"id" db:"id"` + CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"` + ExpiresAt time.Time `json:"expiresAt,omitzero" db:"expires_at"` + Type PersonalAccessTokenType `json:"type" db:"type"` + PublicKey string `json:"-" db:"public_key"` + Scopes []string `json:"scopes" db:"scopes"` +} + +//go:generate enumer -type PersonalAccessTokenType -transform lower -trimprefix PersonalAccessTokenType + +type PersonalAccessTokenType uint8 + +const ( + PersonalAccessTokenTypeUnspecified PersonalAccessTokenType = iota + PersonalAccessTokenTypeBearer + PersonalAccessTokenTypeJWT +) + +type MachineKey struct { + ID string `json:"id" db:"id"` + PublicKey []byte `json:"-" db:"public_key"` + CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"` + ExpiresAt time.Time `json:"expiresAt,omitzero" db:"expires_at"` + Type MachineKeyType `json:"type" db:"type"` +} + +//go:generate enumer -type MachineKeyType -transform lower -trimprefix MachineKeyType + +type MachineKeyType uint8 + +const ( + MachineKeyTypeUnspecified MachineKeyType = iota + MachineKeyTypeJSON + MachineKeyTypeNone +) + +type Passkey struct { + ID string `json:"id" db:"id"` + KeyID []byte `json:"-" db:"key_id"` + Name string `json:"name" db:"name"` + SignCount uint32 `json:"-" db:"sign_count"` + PublicKey []byte `json:"-" db:"public_key"` + AttestationType string `json:"attestationType" db:"attestation_type"` + AuthenticatorAttestationGUID []byte `json:"aaGuid" db:"authenticator_attestation_guid"` + Type PasskeyType `json:"type" db:"type"` + + CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"` + UpdatedAt time.Time `json:"updatedAt,omitzero" db:"updated_at"` + VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"` + + // Challenge is used during device registration + Challenge []byte `json:"-" db:"challenge"` + // RelyingPartyID is used during device registration + RelyingPartyID string `json:"-" db:"relying_party_id"` + + // Initialization is used during user registration + Initialization *Verification `json:"-" db:"initialization"` +} + +//go:generate enumer -type PasskeyType -transform lower -trimprefix PasskeyType + +type PasskeyType uint8 + +const ( + PasskeyTypeUnspecified PasskeyType = iota + PasskeyTypePasswordless + PasskeyTypeU2F +) + +type IdentityProviderLink struct { + ProviderID string `json:"providerId" db:"provider_id"` + ProvidedUserID string `json:"providedUserId" db:"provided_user_id"` + ProvidedUsername string `json:"providedUsername" db:"provided_username"` + + CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"` + UpdatedAt time.Time `json:"updatedAt,omitzero" db:"updated_at"` +} + +//go:generate enumer -type UserType -transform lower -trimprefix UserType + +type UserType uint8 + +const ( + UserTypeUnspecified UserType = iota + UserTypeHuman + UserTypeMachine +) diff --git a/backend/v3/domain/user_repo.go b/backend/v3/domain/user_repo.go new file mode 100644 index 000000000..fbfcfec89 --- /dev/null +++ b/backend/v3/domain/user_repo.go @@ -0,0 +1,314 @@ +package domain + +import ( + "context" + "time" + + "golang.org/x/text/language" + + "github.com/zitadel/zitadel/backend/v3/storage/database" +) + +//go:generate mockgen -typed -package domainmock -destination ./mock/user.mock.go . UserRepository + +type UserRepository interface { + Repository + Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*User, error) + List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*User, error) + Create(ctx context.Context, client database.QueryExecutor, user *User) error + Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) + Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) + + Human() HumanUserRepository + Machine() MachineUserRepository + + LoadMetadata() UserRepository + LoadPasskeys() UserRepository + LoadIdentityProviderLinks() UserRepository + LoadVerifications() UserRepository + LoadPATs() UserRepository + LoadKeys() UserRepository + + userConditions + userChanges + userColumns +} + +type userConditions interface { + PrimaryKeyCondition(instanceID, userID string) database.Condition + InstanceIDCondition(instanceID string) database.Condition + OrgIDCondition(orgID string) database.Condition + IDCondition(userID string) database.Condition + UsernameCondition(op database.TextOperation, username string) database.Condition + StateCondition(state UserState) database.Condition + TypeCondition(userType UserType) database.Condition + LoginNameCondition(op database.TextOperation, loginName string) database.Condition + + userMetadataConditions +} + +type userMetadataConditions interface { + ExistsMetadata(condition database.Condition) database.Condition + MetadataKeyCondition(op database.TextOperation, key string) database.Condition + MetadataValueCondition(op database.BytesOperation, value []byte) database.Condition +} + +type userChanges interface { + // SetUsername sets the username field + SetUsername(username string) database.Change + // SetState sets the state field + // [UserStateUnspecified] is not allowed and will result in no change + SetState(state UserState) database.Change + // SetUpdatedAt sets the updated at field + // This is used to replay events + SetUpdatedAt(updatedAt time.Time) database.Change + // AddMetadata adds metadata for the user + AddMetadata(metadata ...*Metadata) database.Change + // RemoveMetadata removes the metadata for the user + // Use one of the following conditions to specify which metadata to remove: + // - [userMetadataConditions.MetadataKeyCondition] + // - [userMetadataConditions.MetadataValueCondition] + // - nil to remove all metadata for the user + RemoveMetadata(condition database.Condition) database.Change +} + +type userColumns interface { + PrimaryKeyColumns() []database.Column + UsernameColumn() database.Column + StateColumn() database.Column + TypeColumn() database.Column + CreatedAtColumn() database.Column +} + +//go:generate mockgen -typed -package domainmock -destination ./mock/human_user.mock.go . HumanUserRepository + +type HumanUserRepository interface { + // Update updates the human user + // It ensures that updates are only applied to human users + Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) + humanConditions + humanChanges + humanColumns +} + +type humanConditions interface { + userConditions + FirstNameCondition(op database.TextOperation, firstName string) database.Condition + LastNameCondition(op database.TextOperation, lastName string) database.Condition + NicknameCondition(op database.TextOperation, nickname string) database.Condition + DisplayNameCondition(op database.TextOperation, displayName string) database.Condition + PreferredLanguageCondition(lang language.Tag) database.Condition + EmailCondition(op database.TextOperation, email string) database.Condition + PhoneCondition(op database.TextOperation, phone string) database.Condition + PasskeyIDCondition(passkeyID string) database.Condition + IdentityProviderIDCondition(idpID string) database.Condition + ProvidedUserIDCondition(providedUserID string) database.Condition + ProvidedUsernameCondition(username string) database.Condition + + humanPasskeyConditions +} + +type humanChanges interface { + userChanges + // SetFirstName sets the first name field + SetFirstName(firstName string) database.Change + // SetLastName sets the last name field + SetLastName(lastName string) database.Change + // SetNickname sets the nickname field + SetNickname(nickname string) database.Change + // SetDisplayName sets the display name field + SetDisplayName(displayName string) database.Change + // SetPreferredLanguage sets the preferred language field + // If preferredLanguage is [language.Und], it will be set to NULL in the database + SetPreferredLanguage(preferredLanguage language.Tag) database.Change + // SetGender sets the gender field + // If gender is [HumanGenderUnspecified], it will be set to NULL in the database + SetGender(gender HumanGender) database.Change + // SetAvatarKey sets the avatar key field + // If avatarKey is nil, it will be set to NULL in the database + SetAvatarKey(avatarKey *string) database.Change + // SetMultifactorInitializationSkippedAt sets the multifactor initialization skipped at field + SetMultifactorInitializationSkippedAt(skippedAt time.Time) database.Change + + // SetPassword sets the password based on the verification + SetPassword(verification VerificationType) database.Change + // SetPasswordChangeRequired sets whether a password change is required + SetPasswordChangeRequired(required bool) database.Change + // CheckPassword sets the password check based on the check type + // * [CheckTypeFailed] increments failed attempts + // * [CheckTypeSucceeded] to mark the check as succeeded, removes the check and updates verified at time + CheckPassword(check PasswordCheckType) database.Change + + // SetVerification sets the verification based on the verification type + SetVerification(id string, verification VerificationType) database.Change + + humanEmailChanges + humanPhoneChanges + humanTOTPChanges + identityProviderLinkChanges + humanPasskeyChanges +} + +type humanEmailChanges interface { + // SetEmail sets the email based on the verification + // * [VerificationTypeInit] to initialize email verification, previously verified email remains verified + // * [VerificationTypeVerified] to mark email as verified, a verification must exist + // * [VerificationTypeUpdate] to update email verification, a verification must exist (e.g. resend code) + // * [VerificationTypeSkipped] to skip email verification, existing verification is removed (e.g. admin set email) + SetEmail(verification VerificationType) database.Change + // CheckEmailOTP sets the email OTP based on the check + // * [CheckTypeInit] to initialize a new check, previous check is overwritten + // * [CheckTypeFailed] increments failed attempts + // * [CheckTypeSucceeded] to mark the check as succeeded, removes the check and updates verified at time + CheckEmailOTP(check CheckType) database.Change + // EnableEmailOTPAt enables the email OTP + // If enabledAt is zero, it will be set to NOW() + EnableEmailOTPAt(enabledAt time.Time) database.Change + // EnableEmailOTP sets the enabled at time to NOW() + EnableEmailOTP() database.Change + // DisableEmailOTP clears the enabled at time + DisableEmailOTP() database.Change +} + +type humanPhoneChanges interface { + // SetPhone sets the phone based on the verification + // * [VerificationTypeInit] to initialize phone verification, previously verified phone remains verified + // * [VerificationTypeVerified] to mark phone as verified, a verification must exist + // * [VerificationTypeUpdate] to update phone verification, a verification must exist (e.g. resend code) + // * [VerificationTypeSkipped] to skip phone verification, existing verification is removed (e.g. admin set phone) + SetPhone(verification VerificationType) database.Change + // RemovePhone removes the phone number + RemovePhone() database.Change + // CheckSMSOTP sets the SMS OTP based on the check + // * [CheckTypeInit] to initialize a new check, previous check is overwritten + // * [CheckTypeFailed] increments failed attempts + // * [CheckTypeSucceeded] to mark the check as succeeded, removes the check and updates verified at time + CheckSMSOTP(check CheckType) database.Change + // EnableSMSOTPAt enables the SMS OTP + // If enabledAt is zero, it will be set to NOW() + EnableSMSOTPAt(enabledAt time.Time) database.Change + // EnableSMSOTP sets the enabled at time to NOW() + EnableSMSOTP() database.Change + // DisableSMSOTP clears the enabled at time + DisableSMSOTP() database.Change +} + +type humanTOTPChanges interface { + // SetTOTP changes the TOTP secret based on the verification + // * [VerificationTypeInit] to initialize totp verification, previously verified totp remains verified + // * [VerificationTypeVerified] to mark totp as verified, a verification must exist + // * [VerificationTypeUpdate] to update totp verification, a verification must exist (e.g. resend code) + // * [VerificationTypeSkipped] to skip totp verification, existing verification is removed (e.g. admin set totp) + SetTOTP(verification VerificationType) database.Change + // SetTOTPCheck sets the TOTP check based on the check type + // * [CheckTypeFailed] increments failed attempts + // * [CheckTypeSucceeded] to mark the check as succeeded, removes the check and updates verified at time + // * [CheckTypeInit] is not allowed for TOTP + CheckTOTP(check CheckType) database.Change + // RemoveTOTP removes the TOTP + RemoveTOTP() database.Change +} + +type identityProviderLinkChanges interface { + // AddIdentityProviderLink adds or updates an identity provider link + AddIdentityProviderLink(link *IdentityProviderLink) database.Change + UpdateIdentityProviderLink(changes ...database.Change) database.Change + // RemoveIdentityProviderLink removes an identity provider link based on the condition + RemoveIdentityProviderLink(providerID, providedUserID string) database.Change + + // SetIdentityProviderLinkUsername sets the username for an identity provider link + SetIdentityProviderLinkUsername(providerID, providedUserID, username string) database.Change + // SetIdentityProviderLinkProvidedID sets the provided user ID for an identity provider link + SetIdentityProviderLinkProvidedID(providerID, currentProvidedUserID, newProvidedUserID string) database.Change +} + +type humanColumns interface { + userColumns + FirstNameColumn() database.Column + LastNameColumn() database.Column + NicknameColumn() database.Column + DisplayNameColumn() database.Column + EmailColumn() database.Column +} + +//go:generate mockgen -typed -package domainmock -destination ./mock/machine_user.mock.go . MachineUserRepository + +type MachineUserRepository interface { + // Update updates the machine user + // It ensures that updates are only applied to machine users + Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) + machineConditions + machineChanges + machineColumns +} + +type machineConditions interface { + userConditions +} + +type machineChanges interface { + userChanges + // SetName sets the name field + SetName(name string) database.Change + // SetDescription sets the description field + SetDescription(description string) database.Change + // SetSecret sets the secret field + // nil will set the secret to NULL in the database + SetSecret(secret *string) database.Change + // SetAccessTokenType sets the personal access token type field + SetAccessTokenType(tokenType PersonalAccessTokenType) database.Change + + // AddKey adds a key for the machine user + AddKey(key *MachineKey) database.Change + // RemoveKey removes a key for the machine user + RemoveKey(id string) database.Change + + // AddPersonalAccessToken adds a personal access token for the machine user + AddPersonalAccessToken(pat *PersonalAccessToken) database.Change + // RemovePersonalAccessToken removes a personal access token for the machine user + RemovePersonalAccessToken(id string) database.Change +} + +type machineColumns interface { + userColumns +} + +type humanPasskeyConditions interface { + PasskeyIDCondition(passkeyID string) database.Condition + PasskeyKeyIDCondition(keyID string) database.Condition + PasskeyChallengeCondition(challenge string) database.Condition +} + +type humanPasskeyChanges interface { + // AddPasskey adds a passkey for the user + AddPasskey(passkey *Passkey) database.Change + // UpdatePasskey updates a passkey for the user. + // The condition must specify which passkey to update, use [humanPasskeyConditions]. + // Use [humanPasskeyFieldChanges] to specify the fields to update. + UpdatePasskey(condition database.Condition, changes ...database.Change) database.Change + // RemovePasskey removes a passkey for the user + // The condition must specify which passkey to update, use [humanPasskeyConditions]. + RemovePasskey(condition database.Condition) database.Change + + passkeyFieldChanges +} + +type passkeyFieldChanges interface { + // SetPasskeyKeyID sets the key ID field + SetPasskeyKeyID(keyID []byte) database.Change + // SetPasskeyPublicKey sets the public key field + SetPasskeyPublicKey(publicKey []byte) database.Change + // SetPasskeyAttestationType sets the attestation type field + SetPasskeyAttestationType(attestationType string) database.Change + // SetPasskeyAuthenticatorAttestationGUID sets the AAGUID field + SetPasskeyAuthenticatorAttestationGUID(aaguid []byte) database.Change + // SetPasskeyName sets the name field + SetPasskeyName(name string) database.Change + // SetPasskeySignCount sets the sign count field + SetPasskeySignCount(signCount uint32) database.Change + // SetPasskeyUpdatedAt sets the updated at field + SetPasskeyUpdatedAt(updatedAt time.Time) database.Change + // SetPasskeyVerifiedAt sets the verified at field + // If verifiedAt is zero, it will be set to NOW() + SetPasskeyVerifiedAt(verifiedAt time.Time) database.Change +} diff --git a/backend/v3/domain/userstate_enumer.go b/backend/v3/domain/userstate_enumer.go new file mode 100644 index 000000000..f67675e84 --- /dev/null +++ b/backend/v3/domain/userstate_enumer.go @@ -0,0 +1,121 @@ +// Code generated by "enumer -type UserState -transform lower -trimprefix UserState -sql"; DO NOT EDIT. + +package domain + +import ( + "database/sql/driver" + "fmt" + "strings" +) + +const _UserStateName = "unspecifiedactiveinactivelockedinitial" + +var _UserStateIndex = [...]uint8{0, 11, 17, 25, 31, 38} + +const _UserStateLowerName = "unspecifiedactiveinactivelockedinitial" + +func (i UserState) String() string { + if i >= UserState(len(_UserStateIndex)-1) { + return fmt.Sprintf("UserState(%d)", i) + } + return _UserStateName[_UserStateIndex[i]:_UserStateIndex[i+1]] +} + +// An "invalid array index" compiler error signifies that the constant values have changed. +// Re-run the stringer command to generate them again. +func _UserStateNoOp() { + var x [1]struct{} + _ = x[UserStateUnspecified-(0)] + _ = x[UserStateActive-(1)] + _ = x[UserStateInactive-(2)] + _ = x[UserStateLocked-(3)] + _ = x[UserStateInitial-(4)] +} + +var _UserStateValues = []UserState{UserStateUnspecified, UserStateActive, UserStateInactive, UserStateLocked, UserStateInitial} + +var _UserStateNameToValueMap = map[string]UserState{ + _UserStateName[0:11]: UserStateUnspecified, + _UserStateLowerName[0:11]: UserStateUnspecified, + _UserStateName[11:17]: UserStateActive, + _UserStateLowerName[11:17]: UserStateActive, + _UserStateName[17:25]: UserStateInactive, + _UserStateLowerName[17:25]: UserStateInactive, + _UserStateName[25:31]: UserStateLocked, + _UserStateLowerName[25:31]: UserStateLocked, + _UserStateName[31:38]: UserStateInitial, + _UserStateLowerName[31:38]: UserStateInitial, +} + +var _UserStateNames = []string{ + _UserStateName[0:11], + _UserStateName[11:17], + _UserStateName[17:25], + _UserStateName[25:31], + _UserStateName[31:38], +} + +// UserStateString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func UserStateString(s string) (UserState, error) { + if val, ok := _UserStateNameToValueMap[s]; ok { + return val, nil + } + + if val, ok := _UserStateNameToValueMap[strings.ToLower(s)]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to UserState values", s) +} + +// UserStateValues returns all values of the enum +func UserStateValues() []UserState { + return _UserStateValues +} + +// UserStateStrings returns a slice of all String values of the enum +func UserStateStrings() []string { + strs := make([]string, len(_UserStateNames)) + copy(strs, _UserStateNames) + return strs +} + +// IsAUserState returns "true" if the value is listed in the enum definition. "false" otherwise +func (i UserState) IsAUserState() bool { + for _, v := range _UserStateValues { + if i == v { + return true + } + } + return false +} + +func (i UserState) Value() (driver.Value, error) { + return i.String(), nil +} + +func (i *UserState) Scan(value interface{}) error { + if value == nil { + return nil + } + + var str string + switch v := value.(type) { + case []byte: + str = string(v) + case string: + str = v + case fmt.Stringer: + str = v.String() + default: + return fmt.Errorf("invalid value of UserState: %[1]T(%[1]v)", value) + } + + val, err := UserStateString(str) + if err != nil { + return err + } + + *i = val + return nil +} diff --git a/backend/v3/domain/usertype_enumer.go b/backend/v3/domain/usertype_enumer.go new file mode 100644 index 000000000..e93389b87 --- /dev/null +++ b/backend/v3/domain/usertype_enumer.go @@ -0,0 +1,82 @@ +// Code generated by "enumer -type UserType -transform lower -trimprefix UserType"; DO NOT EDIT. + +package domain + +import ( + "fmt" + "strings" +) + +const _UserTypeName = "unspecifiedhumanmachine" + +var _UserTypeIndex = [...]uint8{0, 11, 16, 23} + +const _UserTypeLowerName = "unspecifiedhumanmachine" + +func (i UserType) String() string { + if i >= UserType(len(_UserTypeIndex)-1) { + return fmt.Sprintf("UserType(%d)", i) + } + return _UserTypeName[_UserTypeIndex[i]:_UserTypeIndex[i+1]] +} + +// An "invalid array index" compiler error signifies that the constant values have changed. +// Re-run the stringer command to generate them again. +func _UserTypeNoOp() { + var x [1]struct{} + _ = x[UserTypeUnspecified-(0)] + _ = x[UserTypeHuman-(1)] + _ = x[UserTypeMachine-(2)] +} + +var _UserTypeValues = []UserType{UserTypeUnspecified, UserTypeHuman, UserTypeMachine} + +var _UserTypeNameToValueMap = map[string]UserType{ + _UserTypeName[0:11]: UserTypeUnspecified, + _UserTypeLowerName[0:11]: UserTypeUnspecified, + _UserTypeName[11:16]: UserTypeHuman, + _UserTypeLowerName[11:16]: UserTypeHuman, + _UserTypeName[16:23]: UserTypeMachine, + _UserTypeLowerName[16:23]: UserTypeMachine, +} + +var _UserTypeNames = []string{ + _UserTypeName[0:11], + _UserTypeName[11:16], + _UserTypeName[16:23], +} + +// UserTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func UserTypeString(s string) (UserType, error) { + if val, ok := _UserTypeNameToValueMap[s]; ok { + return val, nil + } + + if val, ok := _UserTypeNameToValueMap[strings.ToLower(s)]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to UserType values", s) +} + +// UserTypeValues returns all values of the enum +func UserTypeValues() []UserType { + return _UserTypeValues +} + +// UserTypeStrings returns a slice of all String values of the enum +func UserTypeStrings() []string { + strs := make([]string, len(_UserTypeNames)) + copy(strs, _UserTypeNames) + return strs +} + +// IsAUserType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i UserType) IsAUserType() bool { + for _, v := range _UserTypeValues { + if i == v { + return true + } + } + return false +} diff --git a/backend/v3/domain/verification.go b/backend/v3/domain/verification.go new file mode 100644 index 000000000..d331a13da --- /dev/null +++ b/backend/v3/domain/verification.go @@ -0,0 +1,79 @@ +package domain + +import "time" + +type Verification struct { + Value *string `db:"value"` + Code []byte `db:"code"` + ExpiresAt *time.Time `db:"expires_at"` + FailedAttempts uint8 `db:"failed_attempts"` + VerifiedAt time.Time `db:"verified_at"` +} + +type VerificationType interface { + isVerificationType() +} + +// VerificationTypeInit indicates that an object which needs verification is created. +type VerificationTypeInit struct { + // CreatedAt is the time when the verification was created. + // If zero, the current time will be used. + CreatedAt time.Time + // Expiry is the duration after which the verification expires. + Expiry *time.Duration + // Code is the code to be used for verification. + Code []byte + // Value is the value to be set after successful verification. + Value *string +} + +// isVerificationType implements [VerificationType]. +func (v *VerificationTypeInit) isVerificationType() {} + +var _ VerificationType = (*VerificationTypeInit)(nil) + +// VerificationTypeVerified indicates that the verification was successful. +// If VerifiedAt is zero, the current time will be used. +// If the Value of the verification is present, it is used as the new value to be set. +type VerificationTypeVerified struct { + VerifiedAt time.Time +} + +// isVerificationType implements [VerificationType]. +func (v *VerificationTypeVerified) isVerificationType() {} + +var _ VerificationType = (*VerificationTypeVerified)(nil) + +// VerificationTypeUpdate updates an existing verification. +// Non-nil fields get updated. +type VerificationTypeUpdate struct { + Code []byte + Value *string + Expiry *time.Duration +} + +// isVerificationType implements [VerificationType]. +func (v *VerificationTypeUpdate) isVerificationType() {} + +var _ VerificationType = (*VerificationTypeUpdate)(nil) + +// VerificationTypeSkipped indicates that the verification was skipped. +// If Value is present, it is used as the new value to be set. +type VerificationTypeSkipped struct { + VerifiedAt time.Time + Value *string +} + +// isVerificationType implements [VerificationType]. +func (v *VerificationTypeSkipped) isVerificationType() {} + +var _ VerificationType = (*VerificationTypeSkipped)(nil) + +type VerificationTypeFailed struct { + FailedAt time.Time +} + +// isVerificationType implements [VerificationType]. +func (v *VerificationTypeFailed) isVerificationType() {} + +var _ VerificationType = (*VerificationTypeFailed)(nil) diff --git a/backend/v3/storage/database/operators_enumer.go b/backend/v3/storage/database/operators_enumer.go index 2a72aee18..8589cf023 100644 --- a/backend/v3/storage/database/operators_enumer.go +++ b/backend/v3/storage/database/operators_enumer.go @@ -94,11 +94,11 @@ func (i NumberOperation) IsANumberOperation() bool { return false } -const _TextOperationName = "=<>LIKELIKELIKELIKELIKELIKE" +const _TextOperationName = "=<>LIKELIKELIKELIKELIKELIKE=<>" -var _TextOperationIndex = [...]uint8{0, 1, 3, 7, 11, 15, 19, 23, 27} +var _TextOperationIndex = [...]uint8{0, 1, 3, 7, 11, 15, 19, 23, 27, 28, 30} -const _TextOperationLowerName = "=<>likelikelikelikelikelike" +const _TextOperationLowerName = "=<>likelikelikelikelikelike=<>" func (i TextOperation) String() string { i -= 1 @@ -120,9 +120,11 @@ func _TextOperationNoOp() { _ = x[TextOperationContainsIgnoreCase-(6)] _ = x[TextOperationEndsWithIgnoreCase-(7)] _ = x[TextOperationStartsWithIgnoreCase-(8)] + _ = x[TextOperationEqualIgnoreCase-(9)] + _ = x[TextOperationNotEqualIgnoreCase-(10)] } -var _TextOperationValues = []TextOperation{TextOperationEqual, TextOperationNotEqual, TextOperationStartsWith, TextOperationContains, TextOperationEndsWith, TextOperationContainsIgnoreCase, TextOperationEndsWithIgnoreCase, TextOperationStartsWithIgnoreCase} +var _TextOperationValues = []TextOperation{TextOperationEqual, TextOperationNotEqual, TextOperationStartsWith, TextOperationContains, TextOperationEndsWith, TextOperationContainsIgnoreCase, TextOperationEndsWithIgnoreCase, TextOperationStartsWithIgnoreCase, TextOperationEqualIgnoreCase, TextOperationNotEqualIgnoreCase} var _TextOperationNameToValueMap = map[string]TextOperation{ _TextOperationName[0:1]: TextOperationEqual, @@ -141,6 +143,10 @@ var _TextOperationNameToValueMap = map[string]TextOperation{ _TextOperationLowerName[19:23]: TextOperationEndsWithIgnoreCase, _TextOperationName[23:27]: TextOperationStartsWithIgnoreCase, _TextOperationLowerName[23:27]: TextOperationStartsWithIgnoreCase, + _TextOperationName[27:28]: TextOperationEqualIgnoreCase, + _TextOperationLowerName[27:28]: TextOperationEqualIgnoreCase, + _TextOperationName[28:30]: TextOperationNotEqualIgnoreCase, + _TextOperationLowerName[28:30]: TextOperationNotEqualIgnoreCase, } var _TextOperationNames = []string{ @@ -152,6 +158,8 @@ var _TextOperationNames = []string{ _TextOperationName[15:19], _TextOperationName[19:23], _TextOperationName[23:27], + _TextOperationName[27:28], + _TextOperationName[28:30], } // TextOperationString retrieves an enum value from the enum constants string name. diff --git a/backend/v3/storage/database/repository/user.go b/backend/v3/storage/database/repository/user.go deleted file mode 100644 index c6e15a72c..000000000 --- a/backend/v3/storage/database/repository/user.go +++ /dev/null @@ -1,291 +0,0 @@ -package repository - -import ( - "context" - "time" - - "github.com/zitadel/zitadel/backend/v3/domain" - "github.com/zitadel/zitadel/backend/v3/storage/database" -) - -const queryUserStmt = `SELECT instance_id, org_id, id, username, type, created_at, updated_at, deleted_at,` + - ` first_name, last_name, email_address, email_verified_at, phone_number, phone_verified_at, description` + - ` FROM users_view users` - -type user struct{} - -func UserRepository() domain.UserRepository { - return new(user) -} - -var _ domain.UserRepository = (*user)(nil) - -// ------------------------------------------------------------- -// repository -// ------------------------------------------------------------- - -// Human implements [domain.UserRepository]. -func (u user) Human() domain.HumanRepository { - return &userHuman{user: u} -} - -// Machine implements [domain.UserRepository]. -func (u user) Machine() domain.MachineRepository { - return &userMachine{user: u} -} - -// List implements [domain.UserRepository]. -func (u user) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (users []*domain.User, err error) { - options := new(database.QueryOpts) - for _, opt := range opts { - opt(options) - } - - builder := database.StatementBuilder{} - builder.WriteString(queryUserStmt) - options.WriteCondition(&builder) - options.WriteOrderBy(&builder) - options.WriteLimit(&builder) - options.WriteOffset(&builder) - - rows, err := client.Query(ctx, builder.String(), builder.Args()...) - if err != nil { - return nil, err - } - defer func() { - closeErr := rows.Close() - if err != nil { - return - } - err = closeErr - }() - for rows.Next() { - user, err := scanUser(rows) - if err != nil { - return nil, err - } - users = append(users, user) - } - if err := rows.Err(); err != nil { - return nil, err - } - return users, nil -} - -// Get implements [domain.UserRepository]. -func (u user) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.User, error) { - options := new(database.QueryOpts) - for _, opt := range opts { - opt(options) - } - - builder := database.StatementBuilder{} - builder.WriteString(queryUserStmt) - options.WriteCondition(&builder) - options.WriteOrderBy(&builder) - options.WriteLimit(&builder) - options.WriteOffset(&builder) - - return scanUser(client.QueryRow(ctx, builder.String(), builder.Args()...)) -} - -const ( - createHumanStmt = `INSERT INTO human_users (instance_id, org_id, user_id, username, first_name, last_name, email_address, email_verified_at, phone_number, phone_verified_at)` + - ` VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)` + - ` RETURNING created_at, updated_at` - createMachineStmt = `INSERT INTO user_machines (instance_id, org_id, user_id, username, description)` + - ` VALUES ($1, $2, $3, $4, $5)` + - ` RETURNING created_at, updated_at` -) - -// Create implements [domain.UserRepository]. -func (u user) Create(ctx context.Context, client database.QueryExecutor, user *domain.User) error { - builder := database.StatementBuilder{} - builder.AppendArgs(user.InstanceID, user.OrgID, user.ID, user.Username, user.Traits.Type()) - switch trait := user.Traits.(type) { - case *domain.Human: - builder.WriteString(createHumanStmt) - builder.AppendArgs(trait.FirstName, trait.LastName, trait.Email.Address, trait.Email.VerifiedAt, trait.Phone.Number, trait.Phone.VerifiedAt) - case *domain.Machine: - builder.WriteString(createMachineStmt) - builder.AppendArgs(trait.Description) - } - return client.QueryRow(ctx, builder.String(), builder.Args()...).Scan(&user.CreatedAt, &user.UpdatedAt) -} - -// Delete implements [domain.UserRepository]. -func (u user) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) error { - builder := database.StatementBuilder{} - builder.WriteString("DELETE FROM users") - writeCondition(&builder, condition) - _, err := client.Exec(ctx, builder.String(), builder.Args()...) - return err -} - -// ------------------------------------------------------------- -// changes -// ------------------------------------------------------------- - -// SetUsername implements [domain.userChanges]. -func (u user) SetUsername(username string) database.Change { - return database.NewChange(u.UsernameColumn(), username) -} - -// ------------------------------------------------------------- -// conditions -// ------------------------------------------------------------- - -func (u user) PrimaryKeyCondition(instanceID, userID string) database.Condition { - return database.And( - u.InstanceIDCondition(instanceID), - u.IDCondition(userID), - ) -} - -// InstanceIDCondition implements [domain.userConditions]. -func (u user) InstanceIDCondition(instanceID string) database.Condition { - return database.NewTextCondition(u.InstanceIDColumn(), database.TextOperationEqual, instanceID) -} - -// OrgIDCondition implements [domain.userConditions]. -func (u user) OrgIDCondition(orgID string) database.Condition { - return database.NewTextCondition(u.OrgIDColumn(), database.TextOperationEqual, orgID) -} - -// IDCondition implements [domain.userConditions]. -func (u user) IDCondition(userID string) database.Condition { - return database.NewTextCondition(u.IDColumn(), database.TextOperationEqual, userID) -} - -// UsernameCondition implements [domain.userConditions]. -func (u user) UsernameCondition(op database.TextOperation, username string) database.Condition { - return database.NewTextCondition(u.UsernameColumn(), op, username) -} - -// CreatedAtCondition implements [domain.userConditions]. -func (u user) CreatedAtCondition(op database.NumberOperation, createdAt time.Time) database.Condition { - return database.NewNumberCondition(u.CreatedAtColumn(), op, createdAt) -} - -// UpdatedAtCondition implements [domain.userConditions]. -func (u user) UpdatedAtCondition(op database.NumberOperation, updatedAt time.Time) database.Condition { - return database.NewNumberCondition(u.UpdatedAtColumn(), op, updatedAt) -} - -// DeletedCondition implements [domain.userConditions]. -func (u user) DeletedCondition(isDeleted bool) database.Condition { - if isDeleted { - return database.IsNotNull(u.DeletedAtColumn()) - } - return database.IsNull(u.DeletedAtColumn()) -} - -// DeletedAtCondition implements [domain.userConditions]. -func (u user) DeletedAtCondition(op database.NumberOperation, deletedAt time.Time) database.Condition { - return database.NewNumberCondition(u.DeletedAtColumn(), op, deletedAt) -} - -// ------------------------------------------------------------- -// columns -// ------------------------------------------------------------- - -// PrimaryKeyColumns implements [domain.Repository]. -func (u user) PrimaryKeyColumns() []database.Column { - return []database.Column{ - u.InstanceIDColumn(), - u.IDColumn(), - } -} - -// InstanceIDColumn implements [domain.userColumns]. -func (user) InstanceIDColumn() database.Column { - return database.NewColumn("users", "instance_id") -} - -// OrgIDColumn implements [domain.userColumns]. -func (user) OrgIDColumn() database.Column { - return database.NewColumn("users", "org_id") -} - -// IDColumn implements [domain.userColumns]. -func (user) IDColumn() database.Column { - return database.NewColumn("users", "id") -} - -// UsernameColumn implements [domain.userColumns]. -func (user) UsernameColumn() database.Column { - return database.NewColumn("users", "username") -} - -// FirstNameColumn implements [domain.userColumns]. -func (user) CreatedAtColumn() database.Column { - return database.NewColumn("users", "created_at") -} - -// UpdatedAtColumn implements [domain.userColumns]. -func (user) UpdatedAtColumn() database.Column { - return database.NewColumn("users", "updated_at") -} - -// DeletedAtColumn implements [domain.userColumns]. -func (user) DeletedAtColumn() database.Column { - return database.NewColumn("users", "deleted_at") -} - -func (u user) columns() database.Columns { - return database.Columns{ - u.InstanceIDColumn(), - u.OrgIDColumn(), - u.IDColumn(), - u.UsernameColumn(), - u.CreatedAtColumn(), - u.UpdatedAtColumn(), - u.DeletedAtColumn(), - } -} - -func scanUser(scanner database.Scanner) (*domain.User, error) { - var ( - user domain.User - human domain.Human - email domain.Email - phone domain.Phone - machine domain.Machine - typ domain.UserType - ) - err := scanner.Scan( - &user.InstanceID, - &user.OrgID, - &user.ID, - &user.Username, - &typ, - &user.CreatedAt, - &user.UpdatedAt, - &user.DeletedAt, - &human.FirstName, - &human.LastName, - &email.Address, - &email.VerifiedAt, - &phone.Number, - &phone.VerifiedAt, - &machine.Description, - ) - if err != nil { - return nil, err - } - - switch typ { - case domain.UserTypeHuman: - if email.Address != "" { - human.Email = &email - } - if phone.Number != "" { - human.Phone = &phone - } - user.Traits = &human - case domain.UserTypeMachine: - user.Traits = &machine - } - - return &user, nil -} diff --git a/backend/v3/storage/database/repository/user_human.go b/backend/v3/storage/database/repository/user_human.go deleted file mode 100644 index 6bacc497d..000000000 --- a/backend/v3/storage/database/repository/user_human.go +++ /dev/null @@ -1,208 +0,0 @@ -package repository - -import ( - "context" - "time" - - "github.com/zitadel/zitadel/backend/v3/domain" - "github.com/zitadel/zitadel/backend/v3/storage/database" -) - -// ------------------------------------------------------------- -// repository -// ------------------------------------------------------------- - -type userHuman struct { - user -} - -var _ domain.HumanRepository = (*userHuman)(nil) - -const userEmailQuery = `SELECT h.email_address, h.email_verified_at FROM user_humans h` - -// GetEmail implements [domain.HumanRepository]. -func (u *userHuman) GetEmail(ctx context.Context, client database.QueryExecutor, condition database.Condition) (*domain.Email, error) { - var email domain.Email - - builder := database.StatementBuilder{} - builder.WriteString(userEmailQuery) - writeCondition(&builder, condition) - - err := client.QueryRow(ctx, builder.String(), builder.Args()...).Scan( - &email.Address, - &email.VerifiedAt, - ) - if err != nil { - return nil, err - } - return &email, nil -} - -// Update implements [domain.HumanRepository]. -func (h userHuman) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) error { - builder := database.StatementBuilder{} - builder.WriteString(`UPDATE human_users SET `) - database.Changes(changes).Write(&builder) - writeCondition(&builder, condition) - - stmt := builder.String() - - _, err := client.Exec(ctx, stmt, builder.Args()...) - return err -} - -// ------------------------------------------------------------- -// changes -// ------------------------------------------------------------- - -// SetFirstName implements [domain.humanChanges]. -func (h userHuman) SetFirstName(firstName string) database.Change { - return database.NewChange(h.FirstNameColumn(), firstName) -} - -// SetLastName implements [domain.humanChanges]. -func (h userHuman) SetLastName(lastName string) database.Change { - return database.NewChange(h.LastNameColumn(), lastName) -} - -// SetEmail implements [domain.humanChanges]. -func (h userHuman) SetEmail(address string, verified *time.Time) database.Change { - return database.NewChanges( - h.SetEmailAddress(address), - database.NewChangePtr(h.EmailVerifiedAtColumn(), verified), - ) -} - -// SetEmailAddress implements [domain.humanChanges]. -func (h userHuman) SetEmailAddress(address string) database.Change { - return database.NewChange(h.EmailAddressColumn(), address) -} - -// SetEmailVerifiedAt implements [domain.humanChanges]. -func (h userHuman) SetEmailVerifiedAt(at time.Time) database.Change { - if at.IsZero() { - return database.NewChange(h.EmailVerifiedAtColumn(), database.NowInstruction) - } - return database.NewChange(h.EmailVerifiedAtColumn(), at) -} - -// SetPhone implements [domain.humanChanges]. -func (h userHuman) SetPhone(number string, verifiedAt *time.Time) database.Change { - return database.NewChanges( - h.SetPhoneNumber(number), - database.NewChangePtr(h.PhoneVerifiedAtColumn(), verifiedAt), - ) -} - -// SetPhoneNumber implements [domain.humanChanges]. -func (h userHuman) SetPhoneNumber(number string) database.Change { - return database.NewChange(h.PhoneNumberColumn(), number) -} - -// SetPhoneVerifiedAt implements [domain.humanChanges]. -func (h userHuman) SetPhoneVerifiedAt(at time.Time) database.Change { - if at.IsZero() { - return database.NewChange(h.PhoneVerifiedAtColumn(), database.NowInstruction) - } - return database.NewChange(h.PhoneVerifiedAtColumn(), at) -} - -// ------------------------------------------------------------- -// conditions -// ------------------------------------------------------------- - -// FirstNameCondition implements [domain.humanConditions]. -func (h userHuman) FirstNameCondition(op database.TextOperation, firstName string) database.Condition { - return database.NewTextCondition(h.FirstNameColumn(), op, firstName) -} - -// LastNameCondition implements [domain.humanConditions]. -func (h userHuman) LastNameCondition(op database.TextOperation, lastName string) database.Condition { - return database.NewTextCondition(h.LastNameColumn(), op, lastName) -} - -// EmailAddressCondition implements [domain.humanConditions]. -func (h userHuman) EmailAddressCondition(op database.TextOperation, email string) database.Condition { - return database.NewTextCondition(h.EmailAddressColumn(), op, email) -} - -// EmailVerifiedCondition implements [domain.humanConditions]. -func (h *userHuman) EmailVerifiedCondition(isVerified bool) database.Condition { - if isVerified { - return database.IsNotNull(h.EmailVerifiedAtColumn()) - } - return database.IsNull(h.EmailVerifiedAtColumn()) -} - -// EmailVerifiedAtCondition implements [domain.humanConditions]. -func (h userHuman) EmailVerifiedAtCondition(op database.NumberOperation, verifiedAt time.Time) database.Condition { - return database.NewNumberCondition(h.EmailVerifiedAtColumn(), op, verifiedAt) -} - -// PhoneNumberCondition implements [domain.humanConditions]. -func (h userHuman) PhoneNumberCondition(op database.TextOperation, phoneNumber string) database.Condition { - return database.NewTextCondition(h.PhoneNumberColumn(), op, phoneNumber) -} - -// PhoneVerifiedCondition implements [domain.humanConditions]. -func (h userHuman) PhoneVerifiedCondition(isVerified bool) database.Condition { - if isVerified { - return database.IsNotNull(h.PhoneVerifiedAtColumn()) - } - return database.IsNull(h.PhoneVerifiedAtColumn()) -} - -// PhoneVerifiedAtCondition implements [domain.humanConditions]. -func (h userHuman) PhoneVerifiedAtCondition(op database.NumberOperation, verifiedAt time.Time) database.Condition { - return database.NewNumberCondition(h.PhoneVerifiedAtColumn(), op, verifiedAt) -} - -// ------------------------------------------------------------- -// columns -// ------------------------------------------------------------- - -// FirstNameColumn implements [domain.humanColumns]. -func (h userHuman) FirstNameColumn() database.Column { - return database.NewColumn("user_humans", "first_name") -} - -// LastNameColumn implements [domain.humanColumns]. -func (h userHuman) LastNameColumn() database.Column { - return database.NewColumn("user_humans", "last_name") -} - -// EmailAddressColumn implements [domain.humanColumns]. -func (h userHuman) EmailAddressColumn() database.Column { - return database.NewColumn("user_humans", "email_address") -} - -// EmailVerifiedAtColumn implements [domain.humanColumns]. -func (h userHuman) EmailVerifiedAtColumn() database.Column { - return database.NewColumn("user_humans", "email_verified_at") -} - -// PhoneNumberColumn implements [domain.humanColumns]. -func (h userHuman) PhoneNumberColumn() database.Column { - return database.NewColumn("user_humans", "phone_number") -} - -// PhoneVerifiedAtColumn implements [domain.humanColumns]. -func (h userHuman) PhoneVerifiedAtColumn() database.Column { - return database.NewColumn("user_humans", "phone_verified_at") -} - -// func (h userHuman) columns() database.Columns { -// return append(h.user.columns(), -// h.FirstNameColumn(), -// h.LastNameColumn(), -// h.EmailAddressColumn(), -// h.EmailVerifiedAtColumn(), -// h.PhoneNumberColumn(), -// h.PhoneVerifiedAtColumn(), -// ) -// } - -// func (h userHuman) writeReturning(builder *database.StatementBuilder) { -// builder.WriteString(" RETURNING ") -// h.columns().Write(builder) -// } diff --git a/backend/v3/storage/database/repository/user_machine.go b/backend/v3/storage/database/repository/user_machine.go deleted file mode 100644 index 82fe87ba5..000000000 --- a/backend/v3/storage/database/repository/user_machine.go +++ /dev/null @@ -1,67 +0,0 @@ -package repository - -import ( - "context" - - "github.com/zitadel/zitadel/backend/v3/domain" - "github.com/zitadel/zitadel/backend/v3/storage/database" -) - -type userMachine struct { - user -} - -var _ domain.MachineRepository = (*userMachine)(nil) - -// ------------------------------------------------------------- -// repository -// ------------------------------------------------------------- - -// Update implements [domain.MachineRepository]. -func (m userMachine) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) error { - builder := database.StatementBuilder{} - builder.WriteString("UPDATE user_machines SET ") - database.Changes(changes).Write(&builder) - writeCondition(&builder, condition) - m.writeReturning() - - _, err := client.Exec(ctx, builder.String(), builder.Args()...) - return err -} - -// ------------------------------------------------------------- -// changes -// ------------------------------------------------------------- - -// SetDescription implements [domain.machineChanges]. -func (m userMachine) SetDescription(description string) database.Change { - return database.NewChange(m.DescriptionColumn(), description) -} - -// ------------------------------------------------------------- -// conditions -// ------------------------------------------------------------- - -// DescriptionCondition implements [domain.machineConditions]. -func (m userMachine) DescriptionCondition(op database.TextOperation, description string) database.Condition { - return database.NewTextCondition(m.DescriptionColumn(), op, description) -} - -// ------------------------------------------------------------- -// columns -// ------------------------------------------------------------- - -// DescriptionColumn implements [domain.machineColumns]. -func (m userMachine) DescriptionColumn() database.Column { - return database.NewColumn("user_machines", "description") -} - -func (m userMachine) columns() database.Columns { - return append(m.user.columns(), m.DescriptionColumn()) -} - -func (m *userMachine) writeReturning() { - builder := database.StatementBuilder{} - builder.WriteString(" RETURNING ") - m.columns().WriteQualified(&builder) -}