feat(session): Password Check API with relation tables (#11804)

# Which Problems Are Solved

As part of #11035 , this PR implements the password check logic for
session validation

# How the Problems Are Solved

- Add system config to default configuration of `domain` package for
easy initialization. Intialize the system settings when Zitadel starts
up
- Add password hasher verify logic to the default configuration of
`domain` package. Initialize it when Zitadel starts up.
  - Add settings repositories with their mocks
  - Implement the logic for doing a password check

# Additional Context

This is a cherry-picked PR + minor changes, coming from
https://github.com/zitadel/zitadel/pull/11164
- Relates to #11035
- Depends on https://github.com/zitadel/zitadel/pull/11777

backend/v3/api/session/v2/convert/session_check_password.go

@@ -0,0 +1,16 @@
+package convert
+
+import (
+	"github.com/zitadel/zitadel/backend/v3/domain"
+	session_grpc "github.com/zitadel/zitadel/pkg/grpc/session/v2"
+)
+
+func CheckPasswordGRPCToDomain(checkPsw *session_grpc.CheckPassword) *domain.CheckPasswordType {
+	if checkPsw == nil {
+		return nil
+	}
+
+	return &domain.CheckPasswordType{
+		Password: checkPsw.GetPassword(),
+	}
+}

backend/v3/api/session/v2/convert/session_check_password_test.go

@@ -0,0 +1,38 @@
+package convert
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/zitadel/zitadel/backend/v3/domain"
+	session_grpc "github.com/zitadel/zitadel/pkg/grpc/session/v2"
+)
+
+func TestCheckPasswordGRPCToDomain(t *testing.T) {
+	t.Parallel()
+	tt := []struct {
+		testName      string
+		inputCheckPsw *session_grpc.CheckPassword
+		expected      *domain.CheckPasswordType
+	}{
+		{testName: "when nil input should return nil output"},
+		{
+			testName:      "when not nil input should return valid output",
+			inputCheckPsw: &session_grpc.CheckPassword{Password: "pw"},
+			expected:      &domain.CheckPasswordType{Password: "pw"},
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.testName, func(t *testing.T) {
+			t.Parallel()
+
+			// Test
+			res := CheckPasswordGRPCToDomain(tc.inputCheckPsw)
+
+			// Verify
+			assert.Equal(t, tc.expected, res)
+		})
+	}
+}

backend/v3/api/session/v2/convert/session_check_user.go

@@ -6,7 +6,7 @@ import (
 	session_grpc "github.com/zitadel/zitadel/pkg/grpc/session/v2"
 )
 
-func CheckUserGRPCToQueryOpt(checkUser *session_grpc.CheckUser) (*domain.CheckUserType, error) {
+func CheckUserGRPCToDomain(checkUser *session_grpc.CheckUser) (*domain.CheckUserType, error) {
 	var toReturn *domain.CheckUserType
 	if checkUser == nil {
 		return toReturn, nil

backend/v3/api/session/v2/convert/session_check_user_test.go

@@ -47,7 +47,7 @@ func TestCheckUserGRPCToQueryOpt(t *testing.T) {
 			t.Parallel()
 
 			// Test
-			res, err := CheckUserGRPCToQueryOpt(tc.inputCheckUser)
+			res, err := CheckUserGRPCToDomain(tc.inputCheckUser)
 
 			// Verify
 			assert.ErrorIs(t, err, tc.expectedError)

backend/v3/domain/defaults.go

@@ -3,11 +3,15 @@ package domain
 import (
 	"github.com/zitadel/zitadel/backend/v3/storage/database"
 	"github.com/zitadel/zitadel/backend/v3/storage/eventstore"
+	"github.com/zitadel/zitadel/internal/config/systemdefaults"
+	"github.com/zitadel/zitadel/internal/crypto"
 )
 
 var (
 	pool             database.Pool
 	legacyEventstore eventstore.LegacyEventstore
+	sysConfig        systemdefaults.SystemDefaults
+	passwordHasher   *crypto.Hasher
 )
 
 func SetPool(p database.Pool) {
@@ -17,3 +21,11 @@ func SetPool(p database.Pool) {
 func SetLegacyEventstore(es eventstore.LegacyEventstore) {
 	legacyEventstore = es
 }
+
+func SetSystemConfig(cfg systemdefaults.SystemDefaults) {
+	sysConfig = cfg
+}
+
+func SetPasswordHasher(hasher *crypto.Hasher) {
+	passwordHasher = hasher
+}

backend/v3/domain/domain_test.go

@@ -3,10 +3,16 @@ package domain_test
 import (
 	"os"
 	"testing"
+
+	"github.com/zitadel/passwap"
+
+	"github.com/zitadel/zitadel/backend/v3/domain"
+	"github.com/zitadel/zitadel/internal/crypto"
 )
 
 func TestMain(m *testing.M) {
 	os.Exit(func() int {
+		domain.SetPasswordHasher(&crypto.Hasher{Swapper: &passwap.Swapper{}})
 		return m.Run()
 	}())
 }

backend/v3/domain/errors.go

@@ -74,3 +74,44 @@ func NewUnexpectedTextQueryOperationError[T any](assertedType T) error {
 func (u *UnexpectedTextQueryOperationError[T]) Error() string {
 	return fmt.Sprintf("Message=unexpected text query operation type '%T'", u.assertedType)
 }
+
+type PasswordVerificationError struct {
+	failedAttempts uint8
+}
+
+func NewPasswordVerificationError(failedPassAttempts uint8) error {
+	return &PasswordVerificationError{
+		failedAttempts: failedPassAttempts,
+	}
+}
+
+func (e *PasswordVerificationError) Error() string {
+	return fmt.Sprintf("Message=failed password attempts (%d)", e.failedAttempts)
+}
+
+func (err *PasswordVerificationError) Is(target error) bool {
+	_, ok := target.(*PasswordVerificationError)
+	return ok
+}
+
+type RowsReturnedMismatchError struct {
+	Msg      string
+	Expected int64
+	Actual   int64
+}
+
+func NewRowsReturnedMismatchError(expected, actual int64) error {
+	return &RowsReturnedMismatchError{
+		Expected: expected,
+		Actual:   actual,
+	}
+}
+
+func (err *RowsReturnedMismatchError) Error() string {
+	return fmt.Sprintf("Message=expecting %d row(s) returned, got %d", err.Expected, err.Actual)
+}
+
+func (err *RowsReturnedMismatchError) Is(target error) bool {
+	_, ok := target.(*RowsReturnedMismatchError)
+	return ok
+}

backend/v3/domain/invoke_option.go

@@ -51,6 +51,12 @@ func WithUserRepo(repo UserRepository) InvokeOpt {
 	}
 }
 
+func WithLockoutSettingsRepo(repo LockoutSettingsRepository) InvokeOpt {
+	return func(opts *InvokeOpts) {
+		opts.lockoutSettingRepo = repo
+	}
+}
+
 func WithPermissionChecker(checker PermissionChecker) InvokeOpt {
 	return func(opts *InvokeOpts) {
 		opts.Permissions = checker
@@ -93,6 +99,9 @@ type InvokeOpts struct {
 	instanceDomainRepo     InstanceDomainRepository
 	sessionRepo            SessionRepository
 	userRepo               UserRepository
+
+	// Settings repos
+	lockoutSettingRepo LockoutSettingsRepository
 }
 
 func (o *InvokeOpts) DB() database.QueryExecutor {

backend/v3/domain/invoker_transaction.go

@@ -19,6 +19,9 @@ func NewTransactionInvoker(next Invoker) *transactionInvoker {
 
 // Transactional is implemented by [Commander]s and [Querier]s wishing to access the DB inside a transaction.
 //
+// It is NOT recommended to use this when non-DB operation inside a transaction take time (e.g. password hash verification).
+// In that case, it is advisable to manually manage the transaction by type asserting [database.Beginner] on db.DB()
+//
 //go:generate mockgen -destination=mock/transactional.mock.go -package=domainmock . Transactional
 type Transactional interface {
 	RequiresTransaction()

backend/v3/domain/mock/domain_settings.mock.go

@@ -0,0 +1,970 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: DomainSettingsRepository)
+//
+// Generated by this command:
+//
+//	mockgen -typed -package domainmock -destination ./mock/domain_settings.mock.go . DomainSettingsRepository
+//
+
+// 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"
+	json "github.com/zitadel/zitadel/backend/v3/storage/database/json"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockDomainSettingsRepository is a mock of DomainSettingsRepository interface.
+type MockDomainSettingsRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockDomainSettingsRepositoryMockRecorder
+	isgomock struct{}
+}
+
+// MockDomainSettingsRepositoryMockRecorder is the mock recorder for MockDomainSettingsRepository.
+type MockDomainSettingsRepositoryMockRecorder struct {
+	mock *MockDomainSettingsRepository
+}
+
+// NewMockDomainSettingsRepository creates a new mock instance.
+func NewMockDomainSettingsRepository(ctrl *gomock.Controller) *MockDomainSettingsRepository {
+	mock := &MockDomainSettingsRepository{ctrl: ctrl}
+	mock.recorder = &MockDomainSettingsRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDomainSettingsRepository) EXPECT() *MockDomainSettingsRepositoryMockRecorder {
+	return m.recorder
+}
+
+// CreatedAtColumn mocks base method.
+func (m *MockDomainSettingsRepository) 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 *MockDomainSettingsRepositoryMockRecorder) CreatedAtColumn() *MockDomainSettingsRepositoryCreatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).CreatedAtColumn))
+	return &MockDomainSettingsRepositoryCreatedAtColumnCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call
+type MockDomainSettingsRepositoryCreatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Delete mocks base method.
+func (m *MockDomainSettingsRepository) 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 *MockDomainSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockDomainSettingsRepositoryDeleteCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDomainSettingsRepository)(nil).Delete), ctx, client, condition)
+	return &MockDomainSettingsRepositoryDeleteCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryDeleteCall wrap *gomock.Call
+type MockDomainSettingsRepositoryDeleteCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockDomainSettingsRepositoryDeleteCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockDomainSettingsRepositoryDeleteCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockDomainSettingsRepositoryDeleteCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Get mocks base method.
+func (m *MockDomainSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.DomainSettings, 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.DomainSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockDomainSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockDomainSettingsRepositoryGetCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDomainSettingsRepository)(nil).Get), varargs...)
+	return &MockDomainSettingsRepositoryGetCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryGetCall wrap *gomock.Call
+type MockDomainSettingsRepositoryGetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryGetCall) Return(arg0 *domain.DomainSettings, arg1 error) *MockDomainSettingsRepositoryGetCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.DomainSettings, error)) *MockDomainSettingsRepositoryGetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.DomainSettings, error)) *MockDomainSettingsRepositoryGetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDColumn mocks base method.
+func (m *MockDomainSettingsRepository) 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 *MockDomainSettingsRepositoryMockRecorder) IDColumn() *MockDomainSettingsRepositoryIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).IDColumn))
+	return &MockDomainSettingsRepositoryIDColumnCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryIDColumnCall wrap *gomock.Call
+type MockDomainSettingsRepositoryIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDCondition mocks base method.
+func (m *MockDomainSettingsRepository) IDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// IDCondition indicates an expected call of IDCondition.
+func (mr *MockDomainSettingsRepositoryMockRecorder) IDCondition(id any) *MockDomainSettingsRepositoryIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).IDCondition), id)
+	return &MockDomainSettingsRepositoryIDConditionCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryIDConditionCall wrap *gomock.Call
+type MockDomainSettingsRepositoryIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockDomainSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockDomainSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDColumn mocks base method.
+func (m *MockDomainSettingsRepository) 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 *MockDomainSettingsRepositoryMockRecorder) InstanceIDColumn() *MockDomainSettingsRepositoryInstanceIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).InstanceIDColumn))
+	return &MockDomainSettingsRepositoryInstanceIDColumnCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call
+type MockDomainSettingsRepositoryInstanceIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDCondition mocks base method.
+func (m *MockDomainSettingsRepository) InstanceIDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InstanceIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// InstanceIDCondition indicates an expected call of InstanceIDCondition.
+func (mr *MockDomainSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockDomainSettingsRepositoryInstanceIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).InstanceIDCondition), id)
+	return &MockDomainSettingsRepositoryInstanceIDConditionCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call
+type MockDomainSettingsRepositoryInstanceIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockDomainSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockDomainSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// List mocks base method.
+func (m *MockDomainSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.DomainSettings, 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.DomainSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockDomainSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockDomainSettingsRepositoryListCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockDomainSettingsRepository)(nil).List), varargs...)
+	return &MockDomainSettingsRepositoryListCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryListCall wrap *gomock.Call
+type MockDomainSettingsRepositoryListCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryListCall) Return(arg0 []*domain.DomainSettings, arg1 error) *MockDomainSettingsRepositoryListCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.DomainSettings, error)) *MockDomainSettingsRepositoryListCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.DomainSettings, error)) *MockDomainSettingsRepositoryListCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDColumn mocks base method.
+func (m *MockDomainSettingsRepository) OrganizationIDColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
+func (mr *MockDomainSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockDomainSettingsRepositoryOrganizationIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).OrganizationIDColumn))
+	return &MockDomainSettingsRepositoryOrganizationIDColumnCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call
+type MockDomainSettingsRepositoryOrganizationIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDCondition mocks base method.
+func (m *MockDomainSettingsRepository) OrganizationIDCondition(id *string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
+func (mr *MockDomainSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockDomainSettingsRepositoryOrganizationIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).OrganizationIDCondition), id)
+	return &MockDomainSettingsRepositoryOrganizationIDConditionCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call
+type MockDomainSettingsRepositoryOrganizationIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockDomainSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockDomainSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyColumns mocks base method.
+func (m *MockDomainSettingsRepository) 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 *MockDomainSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockDomainSettingsRepositoryPrimaryKeyColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockDomainSettingsRepository)(nil).PrimaryKeyColumns))
+	return &MockDomainSettingsRepositoryPrimaryKeyColumnsCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
+type MockDomainSettingsRepositoryPrimaryKeyColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockDomainSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockDomainSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockDomainSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyCondition mocks base method.
+func (m *MockDomainSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
+func (mr *MockDomainSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockDomainSettingsRepositoryPrimaryKeyConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
+	return &MockDomainSettingsRepositoryPrimaryKeyConditionCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call
+type MockDomainSettingsRepositoryPrimaryKeyConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockDomainSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockDomainSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Set mocks base method.
+func (m *MockDomainSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.DomainSettings) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Set", ctx, client, settings)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockDomainSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockDomainSettingsRepositorySetCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDomainSettingsRepository)(nil).Set), ctx, client, settings)
+	return &MockDomainSettingsRepositorySetCall{Call: call}
+}
+
+// MockDomainSettingsRepositorySetCall wrap *gomock.Call
+type MockDomainSettingsRepositorySetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositorySetCall) Return(arg0 error) *MockDomainSettingsRepositorySetCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.DomainSettings) error) *MockDomainSettingsRepositorySetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.DomainSettings) error) *MockDomainSettingsRepositorySetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetLoginNameIncludesDomain mocks base method.
+func (m *MockDomainSettingsRepository) SetLoginNameIncludesDomain(value bool) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetLoginNameIncludesDomain", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetLoginNameIncludesDomain indicates an expected call of SetLoginNameIncludesDomain.
+func (mr *MockDomainSettingsRepositoryMockRecorder) SetLoginNameIncludesDomain(value any) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoginNameIncludesDomain", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetLoginNameIncludesDomain), value)
+	return &MockDomainSettingsRepositorySetLoginNameIncludesDomainCall{Call: call}
+}
+
+// MockDomainSettingsRepositorySetLoginNameIncludesDomainCall wrap *gomock.Call
+type MockDomainSettingsRepositorySetLoginNameIncludesDomainCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall) Return(arg0 json.JsonUpdate) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall) Do(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetRequireOrgDomainVerification mocks base method.
+func (m *MockDomainSettingsRepository) SetRequireOrgDomainVerification(value bool) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetRequireOrgDomainVerification", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetRequireOrgDomainVerification indicates an expected call of SetRequireOrgDomainVerification.
+func (mr *MockDomainSettingsRepositoryMockRecorder) SetRequireOrgDomainVerification(value any) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRequireOrgDomainVerification", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetRequireOrgDomainVerification), value)
+	return &MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall{Call: call}
+}
+
+// MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall wrap *gomock.Call
+type MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall) Return(arg0 json.JsonUpdate) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall) Do(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetSMTPSenderAddressMatchesInstanceDomain mocks base method.
+func (m *MockDomainSettingsRepository) SetSMTPSenderAddressMatchesInstanceDomain(value bool) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetSMTPSenderAddressMatchesInstanceDomain", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetSMTPSenderAddressMatchesInstanceDomain indicates an expected call of SetSMTPSenderAddressMatchesInstanceDomain.
+func (mr *MockDomainSettingsRepositoryMockRecorder) SetSMTPSenderAddressMatchesInstanceDomain(value any) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSMTPSenderAddressMatchesInstanceDomain", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetSMTPSenderAddressMatchesInstanceDomain), value)
+	return &MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall{Call: call}
+}
+
+// MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall wrap *gomock.Call
+type MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall) Return(arg0 json.JsonUpdate) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall) Do(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetSettingFields mocks base method.
+func (m *MockDomainSettingsRepository) SetSettingFields(value domain.DomainSettingsAttributes) database.Change {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetSettingFields", value)
+	ret0, _ := ret[0].(database.Change)
+	return ret0
+}
+
+// SetSettingFields indicates an expected call of SetSettingFields.
+func (mr *MockDomainSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockDomainSettingsRepositorySetSettingFieldsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetSettingFields), value)
+	return &MockDomainSettingsRepositorySetSettingFieldsCall{Call: call}
+}
+
+// MockDomainSettingsRepositorySetSettingFieldsCall wrap *gomock.Call
+type MockDomainSettingsRepositorySetSettingFieldsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockDomainSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositorySetSettingFieldsCall) Do(f func(domain.DomainSettingsAttributes) database.Change) *MockDomainSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.DomainSettingsAttributes) database.Change) *MockDomainSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetUpdatedAt mocks base method.
+func (m *MockDomainSettingsRepository) 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 *MockDomainSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockDomainSettingsRepositorySetUpdatedAtCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetUpdatedAt), updatedAt)
+	return &MockDomainSettingsRepositorySetUpdatedAtCall{Call: call}
+}
+
+// MockDomainSettingsRepositorySetUpdatedAtCall wrap *gomock.Call
+type MockDomainSettingsRepositorySetUpdatedAtCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockDomainSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockDomainSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockDomainSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SettingsColumn mocks base method.
+func (m *MockDomainSettingsRepository) SettingsColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SettingsColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// SettingsColumn indicates an expected call of SettingsColumn.
+func (mr *MockDomainSettingsRepositoryMockRecorder) SettingsColumn() *MockDomainSettingsRepositorySettingsColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SettingsColumn))
+	return &MockDomainSettingsRepositorySettingsColumnCall{Call: call}
+}
+
+// MockDomainSettingsRepositorySettingsColumnCall wrap *gomock.Call
+type MockDomainSettingsRepositorySettingsColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// StateColumn mocks base method.
+func (m *MockDomainSettingsRepository) 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 *MockDomainSettingsRepositoryMockRecorder) StateColumn() *MockDomainSettingsRepositoryStateColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).StateColumn))
+	return &MockDomainSettingsRepositoryStateColumnCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryStateColumnCall wrap *gomock.Call
+type MockDomainSettingsRepositoryStateColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// TypeColumn mocks base method.
+func (m *MockDomainSettingsRepository) TypeColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// TypeColumn indicates an expected call of TypeColumn.
+func (mr *MockDomainSettingsRepositoryMockRecorder) TypeColumn() *MockDomainSettingsRepositoryTypeColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).TypeColumn))
+	return &MockDomainSettingsRepositoryTypeColumnCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryTypeColumnCall wrap *gomock.Call
+type MockDomainSettingsRepositoryTypeColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueColumns mocks base method.
+func (m *MockDomainSettingsRepository) UniqueColumns() []database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueColumns")
+	ret0, _ := ret[0].([]database.Column)
+	return ret0
+}
+
+// UniqueColumns indicates an expected call of UniqueColumns.
+func (mr *MockDomainSettingsRepositoryMockRecorder) UniqueColumns() *MockDomainSettingsRepositoryUniqueColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockDomainSettingsRepository)(nil).UniqueColumns))
+	return &MockDomainSettingsRepositoryUniqueColumnsCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryUniqueColumnsCall wrap *gomock.Call
+type MockDomainSettingsRepositoryUniqueColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockDomainSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockDomainSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockDomainSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueCondition mocks base method.
+func (m *MockDomainSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// UniqueCondition indicates an expected call of UniqueCondition.
+func (mr *MockDomainSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockDomainSettingsRepositoryUniqueConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
+	return &MockDomainSettingsRepositoryUniqueConditionCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryUniqueConditionCall wrap *gomock.Call
+type MockDomainSettingsRepositoryUniqueConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockDomainSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockDomainSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UpdatedAtColumn mocks base method.
+func (m *MockDomainSettingsRepository) 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 *MockDomainSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockDomainSettingsRepositoryUpdatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).UpdatedAtColumn))
+	return &MockDomainSettingsRepositoryUpdatedAtColumnCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call
+type MockDomainSettingsRepositoryUpdatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

backend/v3/domain/mock/human_repo.go

@@ -0,0 +1,31 @@
+package domainmock
+
+import (
+	context "context"
+
+	gomock "go.uber.org/mock/gomock"
+
+	domain "github.com/zitadel/zitadel/backend/v3/domain"
+	database "github.com/zitadel/zitadel/backend/v3/storage/database"
+	"github.com/zitadel/zitadel/backend/v3/storage/database/repository"
+)
+
+func NewHumanRepo(ctrl *gomock.Controller) *HumanRepo {
+	return &HumanRepo{
+		mock:                NewMockHumanUserRepository(ctrl),
+		HumanUserRepository: repository.HumanUserRepository(),
+	}
+}
+
+type HumanRepo struct {
+	domain.HumanUserRepository
+	mock *MockHumanUserRepository
+}
+
+func (u *HumanRepo) EXPECT() *MockHumanUserRepositoryMockRecorder {
+	return u.mock.EXPECT()
+}
+
+func (u *HumanRepo) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) {
+	return u.mock.Update(ctx, client, condition, changes...)
+}

backend/v3/domain/mock/lockout_settings.mock.go

@@ -0,0 +1,970 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: LockoutSettingsRepository)
+//
+// Generated by this command:
+//
+//	mockgen -typed -package domainmock -destination ./mock/lockout_settings.mock.go . LockoutSettingsRepository
+//
+
+// 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"
+	json "github.com/zitadel/zitadel/backend/v3/storage/database/json"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockLockoutSettingsRepository is a mock of LockoutSettingsRepository interface.
+type MockLockoutSettingsRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockLockoutSettingsRepositoryMockRecorder
+	isgomock struct{}
+}
+
+// MockLockoutSettingsRepositoryMockRecorder is the mock recorder for MockLockoutSettingsRepository.
+type MockLockoutSettingsRepositoryMockRecorder struct {
+	mock *MockLockoutSettingsRepository
+}
+
+// NewMockLockoutSettingsRepository creates a new mock instance.
+func NewMockLockoutSettingsRepository(ctrl *gomock.Controller) *MockLockoutSettingsRepository {
+	mock := &MockLockoutSettingsRepository{ctrl: ctrl}
+	mock.recorder = &MockLockoutSettingsRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockLockoutSettingsRepository) EXPECT() *MockLockoutSettingsRepositoryMockRecorder {
+	return m.recorder
+}
+
+// CreatedAtColumn mocks base method.
+func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) CreatedAtColumn() *MockLockoutSettingsRepositoryCreatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).CreatedAtColumn))
+	return &MockLockoutSettingsRepositoryCreatedAtColumnCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryCreatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Delete mocks base method.
+func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockLockoutSettingsRepositoryDeleteCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).Delete), ctx, client, condition)
+	return &MockLockoutSettingsRepositoryDeleteCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryDeleteCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryDeleteCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockLockoutSettingsRepositoryDeleteCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockLockoutSettingsRepositoryDeleteCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockLockoutSettingsRepositoryDeleteCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Get mocks base method.
+func (m *MockLockoutSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.LockoutSettings, 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.LockoutSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockLockoutSettingsRepositoryGetCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).Get), varargs...)
+	return &MockLockoutSettingsRepositoryGetCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryGetCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryGetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryGetCall) Return(arg0 *domain.LockoutSettings, arg1 error) *MockLockoutSettingsRepositoryGetCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LockoutSettings, error)) *MockLockoutSettingsRepositoryGetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LockoutSettings, error)) *MockLockoutSettingsRepositoryGetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDColumn mocks base method.
+func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) IDColumn() *MockLockoutSettingsRepositoryIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).IDColumn))
+	return &MockLockoutSettingsRepositoryIDColumnCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryIDColumnCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDCondition mocks base method.
+func (m *MockLockoutSettingsRepository) IDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// IDCondition indicates an expected call of IDCondition.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) IDCondition(id any) *MockLockoutSettingsRepositoryIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).IDCondition), id)
+	return &MockLockoutSettingsRepositoryIDConditionCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryIDConditionCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockLockoutSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockLockoutSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDColumn mocks base method.
+func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) InstanceIDColumn() *MockLockoutSettingsRepositoryInstanceIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).InstanceIDColumn))
+	return &MockLockoutSettingsRepositoryInstanceIDColumnCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryInstanceIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDCondition mocks base method.
+func (m *MockLockoutSettingsRepository) InstanceIDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InstanceIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// InstanceIDCondition indicates an expected call of InstanceIDCondition.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockLockoutSettingsRepositoryInstanceIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).InstanceIDCondition), id)
+	return &MockLockoutSettingsRepositoryInstanceIDConditionCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryInstanceIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockLockoutSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockLockoutSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// List mocks base method.
+func (m *MockLockoutSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.LockoutSettings, 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.LockoutSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockLockoutSettingsRepositoryListCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).List), varargs...)
+	return &MockLockoutSettingsRepositoryListCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryListCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryListCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryListCall) Return(arg0 []*domain.LockoutSettings, arg1 error) *MockLockoutSettingsRepositoryListCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LockoutSettings, error)) *MockLockoutSettingsRepositoryListCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LockoutSettings, error)) *MockLockoutSettingsRepositoryListCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDColumn mocks base method.
+func (m *MockLockoutSettingsRepository) OrganizationIDColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockLockoutSettingsRepositoryOrganizationIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).OrganizationIDColumn))
+	return &MockLockoutSettingsRepositoryOrganizationIDColumnCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryOrganizationIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDCondition mocks base method.
+func (m *MockLockoutSettingsRepository) OrganizationIDCondition(id *string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockLockoutSettingsRepositoryOrganizationIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).OrganizationIDCondition), id)
+	return &MockLockoutSettingsRepositoryOrganizationIDConditionCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryOrganizationIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockLockoutSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockLockoutSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyColumns mocks base method.
+func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).PrimaryKeyColumns))
+	return &MockLockoutSettingsRepositoryPrimaryKeyColumnsCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryPrimaryKeyColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyCondition mocks base method.
+func (m *MockLockoutSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockLockoutSettingsRepositoryPrimaryKeyConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
+	return &MockLockoutSettingsRepositoryPrimaryKeyConditionCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryPrimaryKeyConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockLockoutSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockLockoutSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Set mocks base method.
+func (m *MockLockoutSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.LockoutSettings) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Set", ctx, client, settings)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockLockoutSettingsRepositorySetCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).Set), ctx, client, settings)
+	return &MockLockoutSettingsRepositorySetCall{Call: call}
+}
+
+// MockLockoutSettingsRepositorySetCall wrap *gomock.Call
+type MockLockoutSettingsRepositorySetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositorySetCall) Return(arg0 error) *MockLockoutSettingsRepositorySetCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.LockoutSettings) error) *MockLockoutSettingsRepositorySetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.LockoutSettings) error) *MockLockoutSettingsRepositorySetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetMaxOTPAttempts mocks base method.
+func (m *MockLockoutSettingsRepository) SetMaxOTPAttempts(value uint64) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetMaxOTPAttempts", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetMaxOTPAttempts indicates an expected call of SetMaxOTPAttempts.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) SetMaxOTPAttempts(value any) *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxOTPAttempts", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetMaxOTPAttempts), value)
+	return &MockLockoutSettingsRepositorySetMaxOTPAttemptsCall{Call: call}
+}
+
+// MockLockoutSettingsRepositorySetMaxOTPAttemptsCall wrap *gomock.Call
+type MockLockoutSettingsRepositorySetMaxOTPAttemptsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall) Return(arg0 json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall) Do(f func(uint64) json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetMaxPasswordAttempts mocks base method.
+func (m *MockLockoutSettingsRepository) SetMaxPasswordAttempts(value uint64) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetMaxPasswordAttempts", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetMaxPasswordAttempts indicates an expected call of SetMaxPasswordAttempts.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) SetMaxPasswordAttempts(value any) *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxPasswordAttempts", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetMaxPasswordAttempts), value)
+	return &MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall{Call: call}
+}
+
+// MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall wrap *gomock.Call
+type MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall) Return(arg0 json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall) Do(f func(uint64) json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetSettingFields mocks base method.
+func (m *MockLockoutSettingsRepository) SetSettingFields(value domain.LockoutSettingsAttributes) database.Change {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetSettingFields", value)
+	ret0, _ := ret[0].(database.Change)
+	return ret0
+}
+
+// SetSettingFields indicates an expected call of SetSettingFields.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockLockoutSettingsRepositorySetSettingFieldsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetSettingFields), value)
+	return &MockLockoutSettingsRepositorySetSettingFieldsCall{Call: call}
+}
+
+// MockLockoutSettingsRepositorySetSettingFieldsCall wrap *gomock.Call
+type MockLockoutSettingsRepositorySetSettingFieldsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockLockoutSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositorySetSettingFieldsCall) Do(f func(domain.LockoutSettingsAttributes) database.Change) *MockLockoutSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.LockoutSettingsAttributes) database.Change) *MockLockoutSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetShowLockOutFailures mocks base method.
+func (m *MockLockoutSettingsRepository) SetShowLockOutFailures(value bool) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetShowLockOutFailures", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetShowLockOutFailures indicates an expected call of SetShowLockOutFailures.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) SetShowLockOutFailures(value any) *MockLockoutSettingsRepositorySetShowLockOutFailuresCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShowLockOutFailures", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetShowLockOutFailures), value)
+	return &MockLockoutSettingsRepositorySetShowLockOutFailuresCall{Call: call}
+}
+
+// MockLockoutSettingsRepositorySetShowLockOutFailuresCall wrap *gomock.Call
+type MockLockoutSettingsRepositorySetShowLockOutFailuresCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositorySetShowLockOutFailuresCall) Return(arg0 json.JsonUpdate) *MockLockoutSettingsRepositorySetShowLockOutFailuresCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositorySetShowLockOutFailuresCall) Do(f func(bool) json.JsonUpdate) *MockLockoutSettingsRepositorySetShowLockOutFailuresCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositorySetShowLockOutFailuresCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLockoutSettingsRepositorySetShowLockOutFailuresCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetUpdatedAt mocks base method.
+func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockLockoutSettingsRepositorySetUpdatedAtCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetUpdatedAt), updatedAt)
+	return &MockLockoutSettingsRepositorySetUpdatedAtCall{Call: call}
+}
+
+// MockLockoutSettingsRepositorySetUpdatedAtCall wrap *gomock.Call
+type MockLockoutSettingsRepositorySetUpdatedAtCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockLockoutSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockLockoutSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockLockoutSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SettingsColumn mocks base method.
+func (m *MockLockoutSettingsRepository) SettingsColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SettingsColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// SettingsColumn indicates an expected call of SettingsColumn.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) SettingsColumn() *MockLockoutSettingsRepositorySettingsColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SettingsColumn))
+	return &MockLockoutSettingsRepositorySettingsColumnCall{Call: call}
+}
+
+// MockLockoutSettingsRepositorySettingsColumnCall wrap *gomock.Call
+type MockLockoutSettingsRepositorySettingsColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// StateColumn mocks base method.
+func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) StateColumn() *MockLockoutSettingsRepositoryStateColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).StateColumn))
+	return &MockLockoutSettingsRepositoryStateColumnCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryStateColumnCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryStateColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// TypeColumn mocks base method.
+func (m *MockLockoutSettingsRepository) TypeColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// TypeColumn indicates an expected call of TypeColumn.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) TypeColumn() *MockLockoutSettingsRepositoryTypeColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).TypeColumn))
+	return &MockLockoutSettingsRepositoryTypeColumnCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryTypeColumnCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryTypeColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueColumns mocks base method.
+func (m *MockLockoutSettingsRepository) UniqueColumns() []database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueColumns")
+	ret0, _ := ret[0].([]database.Column)
+	return ret0
+}
+
+// UniqueColumns indicates an expected call of UniqueColumns.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) UniqueColumns() *MockLockoutSettingsRepositoryUniqueColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).UniqueColumns))
+	return &MockLockoutSettingsRepositoryUniqueColumnsCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryUniqueColumnsCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryUniqueColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockLockoutSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockLockoutSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockLockoutSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueCondition mocks base method.
+func (m *MockLockoutSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// UniqueCondition indicates an expected call of UniqueCondition.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockLockoutSettingsRepositoryUniqueConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
+	return &MockLockoutSettingsRepositoryUniqueConditionCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryUniqueConditionCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryUniqueConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockLockoutSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockLockoutSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UpdatedAtColumn mocks base method.
+func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockLockoutSettingsRepositoryUpdatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).UpdatedAtColumn))
+	return &MockLockoutSettingsRepositoryUpdatedAtColumnCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryUpdatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

backend/v3/domain/mock/lockout_settings_repo.go

@@ -0,0 +1,48 @@
+package domainmock
+
+import (
+	context "context"
+
+	gomock "go.uber.org/mock/gomock"
+
+	domain "github.com/zitadel/zitadel/backend/v3/domain"
+	database "github.com/zitadel/zitadel/backend/v3/storage/database"
+	"github.com/zitadel/zitadel/backend/v3/storage/database/repository"
+)
+
+type LockoutSettingsRepo struct {
+	domain.LockoutSettingsRepository
+	mock *MockLockoutSettingsRepository
+}
+
+func NewLockoutSettingsRepo(ctrl *gomock.Controller) *LockoutSettingsRepo {
+	return &LockoutSettingsRepo{
+		mock:                      NewMockLockoutSettingsRepository(ctrl),
+		LockoutSettingsRepository: repository.LockoutSettingsRepository(),
+	}
+}
+
+func (lsr *LockoutSettingsRepo) EXPECT() *MockLockoutSettingsRepositoryMockRecorder {
+	lsr.mock.ctrl.T.Helper()
+	return lsr.mock.EXPECT()
+}
+
+func (lsr *LockoutSettingsRepo) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.LockoutSettings, error) {
+	lsr.mock.ctrl.T.Helper()
+	return lsr.mock.Get(ctx, client, opts...)
+}
+
+func (lsr *LockoutSettingsRepo) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.LockoutSettings, error) {
+	lsr.mock.ctrl.T.Helper()
+	return lsr.mock.List(ctx, client, opts...)
+}
+
+func (lsr *LockoutSettingsRepo) Set(ctx context.Context, client database.QueryExecutor, settings *domain.LockoutSettings) error {
+	lsr.mock.ctrl.T.Helper()
+	return lsr.mock.Set(ctx, client, settings)
+}
+
+func (lsr *LockoutSettingsRepo) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) {
+	lsr.mock.ctrl.T.Helper()
+	return lsr.mock.Delete(ctx, client, condition)
+}

backend/v3/domain/mock/notification_settings.mock.go

@@ -0,0 +1,894 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: NotificationSettingsRepository)
+//
+// Generated by this command:
+//
+//	mockgen -typed -package domainmock -destination ./mock/notification_settings.mock.go . NotificationSettingsRepository
+//
+
+// 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"
+	json "github.com/zitadel/zitadel/backend/v3/storage/database/json"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockNotificationSettingsRepository is a mock of NotificationSettingsRepository interface.
+type MockNotificationSettingsRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockNotificationSettingsRepositoryMockRecorder
+	isgomock struct{}
+}
+
+// MockNotificationSettingsRepositoryMockRecorder is the mock recorder for MockNotificationSettingsRepository.
+type MockNotificationSettingsRepositoryMockRecorder struct {
+	mock *MockNotificationSettingsRepository
+}
+
+// NewMockNotificationSettingsRepository creates a new mock instance.
+func NewMockNotificationSettingsRepository(ctrl *gomock.Controller) *MockNotificationSettingsRepository {
+	mock := &MockNotificationSettingsRepository{ctrl: ctrl}
+	mock.recorder = &MockNotificationSettingsRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockNotificationSettingsRepository) EXPECT() *MockNotificationSettingsRepositoryMockRecorder {
+	return m.recorder
+}
+
+// CreatedAtColumn mocks base method.
+func (m *MockNotificationSettingsRepository) 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 *MockNotificationSettingsRepositoryMockRecorder) CreatedAtColumn() *MockNotificationSettingsRepositoryCreatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).CreatedAtColumn))
+	return &MockNotificationSettingsRepositoryCreatedAtColumnCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryCreatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Delete mocks base method.
+func (m *MockNotificationSettingsRepository) 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 *MockNotificationSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockNotificationSettingsRepositoryDeleteCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).Delete), ctx, client, condition)
+	return &MockNotificationSettingsRepositoryDeleteCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryDeleteCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryDeleteCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockNotificationSettingsRepositoryDeleteCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockNotificationSettingsRepositoryDeleteCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockNotificationSettingsRepositoryDeleteCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Get mocks base method.
+func (m *MockNotificationSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.NotificationSettings, 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.NotificationSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockNotificationSettingsRepositoryGetCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).Get), varargs...)
+	return &MockNotificationSettingsRepositoryGetCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryGetCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryGetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryGetCall) Return(arg0 *domain.NotificationSettings, arg1 error) *MockNotificationSettingsRepositoryGetCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.NotificationSettings, error)) *MockNotificationSettingsRepositoryGetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.NotificationSettings, error)) *MockNotificationSettingsRepositoryGetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDColumn mocks base method.
+func (m *MockNotificationSettingsRepository) 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 *MockNotificationSettingsRepositoryMockRecorder) IDColumn() *MockNotificationSettingsRepositoryIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).IDColumn))
+	return &MockNotificationSettingsRepositoryIDColumnCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryIDColumnCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDCondition mocks base method.
+func (m *MockNotificationSettingsRepository) IDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// IDCondition indicates an expected call of IDCondition.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) IDCondition(id any) *MockNotificationSettingsRepositoryIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).IDCondition), id)
+	return &MockNotificationSettingsRepositoryIDConditionCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryIDConditionCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockNotificationSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockNotificationSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDColumn mocks base method.
+func (m *MockNotificationSettingsRepository) 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 *MockNotificationSettingsRepositoryMockRecorder) InstanceIDColumn() *MockNotificationSettingsRepositoryInstanceIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).InstanceIDColumn))
+	return &MockNotificationSettingsRepositoryInstanceIDColumnCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryInstanceIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDCondition mocks base method.
+func (m *MockNotificationSettingsRepository) InstanceIDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InstanceIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// InstanceIDCondition indicates an expected call of InstanceIDCondition.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockNotificationSettingsRepositoryInstanceIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).InstanceIDCondition), id)
+	return &MockNotificationSettingsRepositoryInstanceIDConditionCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryInstanceIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockNotificationSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockNotificationSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// List mocks base method.
+func (m *MockNotificationSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.NotificationSettings, 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.NotificationSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockNotificationSettingsRepositoryListCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).List), varargs...)
+	return &MockNotificationSettingsRepositoryListCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryListCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryListCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryListCall) Return(arg0 []*domain.NotificationSettings, arg1 error) *MockNotificationSettingsRepositoryListCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.NotificationSettings, error)) *MockNotificationSettingsRepositoryListCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.NotificationSettings, error)) *MockNotificationSettingsRepositoryListCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDColumn mocks base method.
+func (m *MockNotificationSettingsRepository) OrganizationIDColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockNotificationSettingsRepositoryOrganizationIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).OrganizationIDColumn))
+	return &MockNotificationSettingsRepositoryOrganizationIDColumnCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryOrganizationIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDCondition mocks base method.
+func (m *MockNotificationSettingsRepository) OrganizationIDCondition(id *string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockNotificationSettingsRepositoryOrganizationIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).OrganizationIDCondition), id)
+	return &MockNotificationSettingsRepositoryOrganizationIDConditionCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryOrganizationIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockNotificationSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockNotificationSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyColumns mocks base method.
+func (m *MockNotificationSettingsRepository) 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 *MockNotificationSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).PrimaryKeyColumns))
+	return &MockNotificationSettingsRepositoryPrimaryKeyColumnsCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryPrimaryKeyColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyCondition mocks base method.
+func (m *MockNotificationSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockNotificationSettingsRepositoryPrimaryKeyConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
+	return &MockNotificationSettingsRepositoryPrimaryKeyConditionCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryPrimaryKeyConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockNotificationSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockNotificationSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Set mocks base method.
+func (m *MockNotificationSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.NotificationSettings) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Set", ctx, client, settings)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockNotificationSettingsRepositorySetCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).Set), ctx, client, settings)
+	return &MockNotificationSettingsRepositorySetCall{Call: call}
+}
+
+// MockNotificationSettingsRepositorySetCall wrap *gomock.Call
+type MockNotificationSettingsRepositorySetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositorySetCall) Return(arg0 error) *MockNotificationSettingsRepositorySetCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.NotificationSettings) error) *MockNotificationSettingsRepositorySetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.NotificationSettings) error) *MockNotificationSettingsRepositorySetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetPasswordChange mocks base method.
+func (m *MockNotificationSettingsRepository) SetPasswordChange(value bool) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetPasswordChange", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetPasswordChange indicates an expected call of SetPasswordChange.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) SetPasswordChange(value any) *MockNotificationSettingsRepositorySetPasswordChangeCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordChange", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SetPasswordChange), value)
+	return &MockNotificationSettingsRepositorySetPasswordChangeCall{Call: call}
+}
+
+// MockNotificationSettingsRepositorySetPasswordChangeCall wrap *gomock.Call
+type MockNotificationSettingsRepositorySetPasswordChangeCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositorySetPasswordChangeCall) Return(arg0 json.JsonUpdate) *MockNotificationSettingsRepositorySetPasswordChangeCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositorySetPasswordChangeCall) Do(f func(bool) json.JsonUpdate) *MockNotificationSettingsRepositorySetPasswordChangeCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositorySetPasswordChangeCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockNotificationSettingsRepositorySetPasswordChangeCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetSettingFields mocks base method.
+func (m *MockNotificationSettingsRepository) SetSettingFields(value domain.NotificationSettingsAttributes) database.Change {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetSettingFields", value)
+	ret0, _ := ret[0].(database.Change)
+	return ret0
+}
+
+// SetSettingFields indicates an expected call of SetSettingFields.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockNotificationSettingsRepositorySetSettingFieldsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SetSettingFields), value)
+	return &MockNotificationSettingsRepositorySetSettingFieldsCall{Call: call}
+}
+
+// MockNotificationSettingsRepositorySetSettingFieldsCall wrap *gomock.Call
+type MockNotificationSettingsRepositorySetSettingFieldsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockNotificationSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositorySetSettingFieldsCall) Do(f func(domain.NotificationSettingsAttributes) database.Change) *MockNotificationSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.NotificationSettingsAttributes) database.Change) *MockNotificationSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetUpdatedAt mocks base method.
+func (m *MockNotificationSettingsRepository) 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 *MockNotificationSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockNotificationSettingsRepositorySetUpdatedAtCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SetUpdatedAt), updatedAt)
+	return &MockNotificationSettingsRepositorySetUpdatedAtCall{Call: call}
+}
+
+// MockNotificationSettingsRepositorySetUpdatedAtCall wrap *gomock.Call
+type MockNotificationSettingsRepositorySetUpdatedAtCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockNotificationSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockNotificationSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockNotificationSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SettingsColumn mocks base method.
+func (m *MockNotificationSettingsRepository) SettingsColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SettingsColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// SettingsColumn indicates an expected call of SettingsColumn.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) SettingsColumn() *MockNotificationSettingsRepositorySettingsColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SettingsColumn))
+	return &MockNotificationSettingsRepositorySettingsColumnCall{Call: call}
+}
+
+// MockNotificationSettingsRepositorySettingsColumnCall wrap *gomock.Call
+type MockNotificationSettingsRepositorySettingsColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// StateColumn mocks base method.
+func (m *MockNotificationSettingsRepository) 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 *MockNotificationSettingsRepositoryMockRecorder) StateColumn() *MockNotificationSettingsRepositoryStateColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).StateColumn))
+	return &MockNotificationSettingsRepositoryStateColumnCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryStateColumnCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryStateColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// TypeColumn mocks base method.
+func (m *MockNotificationSettingsRepository) TypeColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// TypeColumn indicates an expected call of TypeColumn.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) TypeColumn() *MockNotificationSettingsRepositoryTypeColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).TypeColumn))
+	return &MockNotificationSettingsRepositoryTypeColumnCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryTypeColumnCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryTypeColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueColumns mocks base method.
+func (m *MockNotificationSettingsRepository) UniqueColumns() []database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueColumns")
+	ret0, _ := ret[0].([]database.Column)
+	return ret0
+}
+
+// UniqueColumns indicates an expected call of UniqueColumns.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) UniqueColumns() *MockNotificationSettingsRepositoryUniqueColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).UniqueColumns))
+	return &MockNotificationSettingsRepositoryUniqueColumnsCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryUniqueColumnsCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryUniqueColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockNotificationSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockNotificationSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockNotificationSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueCondition mocks base method.
+func (m *MockNotificationSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// UniqueCondition indicates an expected call of UniqueCondition.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockNotificationSettingsRepositoryUniqueConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
+	return &MockNotificationSettingsRepositoryUniqueConditionCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryUniqueConditionCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryUniqueConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockNotificationSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockNotificationSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UpdatedAtColumn mocks base method.
+func (m *MockNotificationSettingsRepository) 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 *MockNotificationSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockNotificationSettingsRepositoryUpdatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).UpdatedAtColumn))
+	return &MockNotificationSettingsRepositoryUpdatedAtColumnCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryUpdatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

backend/v3/domain/mock/organization_settings.mock.go

@@ -0,0 +1,894 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: OrganizationSettingsRepository)
+//
+// Generated by this command:
+//
+//	mockgen -typed -package domainmock -destination ./mock/organization_settings.mock.go . OrganizationSettingsRepository
+//
+
+// 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"
+	json "github.com/zitadel/zitadel/backend/v3/storage/database/json"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockOrganizationSettingsRepository is a mock of OrganizationSettingsRepository interface.
+type MockOrganizationSettingsRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockOrganizationSettingsRepositoryMockRecorder
+	isgomock struct{}
+}
+
+// MockOrganizationSettingsRepositoryMockRecorder is the mock recorder for MockOrganizationSettingsRepository.
+type MockOrganizationSettingsRepositoryMockRecorder struct {
+	mock *MockOrganizationSettingsRepository
+}
+
+// NewMockOrganizationSettingsRepository creates a new mock instance.
+func NewMockOrganizationSettingsRepository(ctrl *gomock.Controller) *MockOrganizationSettingsRepository {
+	mock := &MockOrganizationSettingsRepository{ctrl: ctrl}
+	mock.recorder = &MockOrganizationSettingsRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockOrganizationSettingsRepository) EXPECT() *MockOrganizationSettingsRepositoryMockRecorder {
+	return m.recorder
+}
+
+// CreatedAtColumn mocks base method.
+func (m *MockOrganizationSettingsRepository) 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 *MockOrganizationSettingsRepositoryMockRecorder) CreatedAtColumn() *MockOrganizationSettingsRepositoryCreatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).CreatedAtColumn))
+	return &MockOrganizationSettingsRepositoryCreatedAtColumnCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryCreatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Delete mocks base method.
+func (m *MockOrganizationSettingsRepository) 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 *MockOrganizationSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockOrganizationSettingsRepositoryDeleteCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).Delete), ctx, client, condition)
+	return &MockOrganizationSettingsRepositoryDeleteCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryDeleteCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryDeleteCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockOrganizationSettingsRepositoryDeleteCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockOrganizationSettingsRepositoryDeleteCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockOrganizationSettingsRepositoryDeleteCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Get mocks base method.
+func (m *MockOrganizationSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.OrganizationSettings, 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.OrganizationSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockOrganizationSettingsRepositoryGetCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).Get), varargs...)
+	return &MockOrganizationSettingsRepositoryGetCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryGetCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryGetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryGetCall) Return(arg0 *domain.OrganizationSettings, arg1 error) *MockOrganizationSettingsRepositoryGetCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.OrganizationSettings, error)) *MockOrganizationSettingsRepositoryGetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.OrganizationSettings, error)) *MockOrganizationSettingsRepositoryGetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDColumn mocks base method.
+func (m *MockOrganizationSettingsRepository) 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 *MockOrganizationSettingsRepositoryMockRecorder) IDColumn() *MockOrganizationSettingsRepositoryIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).IDColumn))
+	return &MockOrganizationSettingsRepositoryIDColumnCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryIDColumnCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDCondition mocks base method.
+func (m *MockOrganizationSettingsRepository) IDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// IDCondition indicates an expected call of IDCondition.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) IDCondition(id any) *MockOrganizationSettingsRepositoryIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).IDCondition), id)
+	return &MockOrganizationSettingsRepositoryIDConditionCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryIDConditionCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockOrganizationSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockOrganizationSettingsRepositoryIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDColumn mocks base method.
+func (m *MockOrganizationSettingsRepository) 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 *MockOrganizationSettingsRepositoryMockRecorder) InstanceIDColumn() *MockOrganizationSettingsRepositoryInstanceIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).InstanceIDColumn))
+	return &MockOrganizationSettingsRepositoryInstanceIDColumnCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryInstanceIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDCondition mocks base method.
+func (m *MockOrganizationSettingsRepository) InstanceIDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InstanceIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// InstanceIDCondition indicates an expected call of InstanceIDCondition.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockOrganizationSettingsRepositoryInstanceIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).InstanceIDCondition), id)
+	return &MockOrganizationSettingsRepositoryInstanceIDConditionCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryInstanceIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockOrganizationSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockOrganizationSettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// List mocks base method.
+func (m *MockOrganizationSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.OrganizationSettings, 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.OrganizationSettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockOrganizationSettingsRepositoryListCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).List), varargs...)
+	return &MockOrganizationSettingsRepositoryListCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryListCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryListCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryListCall) Return(arg0 []*domain.OrganizationSettings, arg1 error) *MockOrganizationSettingsRepositoryListCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.OrganizationSettings, error)) *MockOrganizationSettingsRepositoryListCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.OrganizationSettings, error)) *MockOrganizationSettingsRepositoryListCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDColumn mocks base method.
+func (m *MockOrganizationSettingsRepository) OrganizationIDColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockOrganizationSettingsRepositoryOrganizationIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).OrganizationIDColumn))
+	return &MockOrganizationSettingsRepositoryOrganizationIDColumnCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryOrganizationIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDCondition mocks base method.
+func (m *MockOrganizationSettingsRepository) OrganizationIDCondition(id *string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockOrganizationSettingsRepositoryOrganizationIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).OrganizationIDCondition), id)
+	return &MockOrganizationSettingsRepositoryOrganizationIDConditionCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryOrganizationIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockOrganizationSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockOrganizationSettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyColumns mocks base method.
+func (m *MockOrganizationSettingsRepository) 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 *MockOrganizationSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).PrimaryKeyColumns))
+	return &MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyCondition mocks base method.
+func (m *MockOrganizationSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
+	return &MockOrganizationSettingsRepositoryPrimaryKeyConditionCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryPrimaryKeyConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Set mocks base method.
+func (m *MockOrganizationSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.OrganizationSettings) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Set", ctx, client, settings)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockOrganizationSettingsRepositorySetCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).Set), ctx, client, settings)
+	return &MockOrganizationSettingsRepositorySetCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositorySetCall wrap *gomock.Call
+type MockOrganizationSettingsRepositorySetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositorySetCall) Return(arg0 error) *MockOrganizationSettingsRepositorySetCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.OrganizationSettings) error) *MockOrganizationSettingsRepositorySetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.OrganizationSettings) error) *MockOrganizationSettingsRepositorySetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetOrganizationScopedUsernames mocks base method.
+func (m *MockOrganizationSettingsRepository) SetOrganizationScopedUsernames(value bool) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetOrganizationScopedUsernames", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetOrganizationScopedUsernames indicates an expected call of SetOrganizationScopedUsernames.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) SetOrganizationScopedUsernames(value any) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOrganizationScopedUsernames", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SetOrganizationScopedUsernames), value)
+	return &MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall wrap *gomock.Call
+type MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall) Return(arg0 json.JsonUpdate) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall) Do(f func(bool) json.JsonUpdate) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetSettingFields mocks base method.
+func (m *MockOrganizationSettingsRepository) SetSettingFields(value domain.OrganizationSettingsAttributes) database.Change {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetSettingFields", value)
+	ret0, _ := ret[0].(database.Change)
+	return ret0
+}
+
+// SetSettingFields indicates an expected call of SetSettingFields.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockOrganizationSettingsRepositorySetSettingFieldsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SetSettingFields), value)
+	return &MockOrganizationSettingsRepositorySetSettingFieldsCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositorySetSettingFieldsCall wrap *gomock.Call
+type MockOrganizationSettingsRepositorySetSettingFieldsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockOrganizationSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositorySetSettingFieldsCall) Do(f func(domain.OrganizationSettingsAttributes) database.Change) *MockOrganizationSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.OrganizationSettingsAttributes) database.Change) *MockOrganizationSettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetUpdatedAt mocks base method.
+func (m *MockOrganizationSettingsRepository) 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 *MockOrganizationSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockOrganizationSettingsRepositorySetUpdatedAtCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SetUpdatedAt), updatedAt)
+	return &MockOrganizationSettingsRepositorySetUpdatedAtCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositorySetUpdatedAtCall wrap *gomock.Call
+type MockOrganizationSettingsRepositorySetUpdatedAtCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockOrganizationSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockOrganizationSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockOrganizationSettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SettingsColumn mocks base method.
+func (m *MockOrganizationSettingsRepository) SettingsColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SettingsColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// SettingsColumn indicates an expected call of SettingsColumn.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) SettingsColumn() *MockOrganizationSettingsRepositorySettingsColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SettingsColumn))
+	return &MockOrganizationSettingsRepositorySettingsColumnCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositorySettingsColumnCall wrap *gomock.Call
+type MockOrganizationSettingsRepositorySettingsColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// StateColumn mocks base method.
+func (m *MockOrganizationSettingsRepository) 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 *MockOrganizationSettingsRepositoryMockRecorder) StateColumn() *MockOrganizationSettingsRepositoryStateColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).StateColumn))
+	return &MockOrganizationSettingsRepositoryStateColumnCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryStateColumnCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryStateColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryStateColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// TypeColumn mocks base method.
+func (m *MockOrganizationSettingsRepository) TypeColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// TypeColumn indicates an expected call of TypeColumn.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) TypeColumn() *MockOrganizationSettingsRepositoryTypeColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).TypeColumn))
+	return &MockOrganizationSettingsRepositoryTypeColumnCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryTypeColumnCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryTypeColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueColumns mocks base method.
+func (m *MockOrganizationSettingsRepository) UniqueColumns() []database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueColumns")
+	ret0, _ := ret[0].([]database.Column)
+	return ret0
+}
+
+// UniqueColumns indicates an expected call of UniqueColumns.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) UniqueColumns() *MockOrganizationSettingsRepositoryUniqueColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).UniqueColumns))
+	return &MockOrganizationSettingsRepositoryUniqueColumnsCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryUniqueColumnsCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryUniqueColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockOrganizationSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockOrganizationSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockOrganizationSettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueCondition mocks base method.
+func (m *MockOrganizationSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// UniqueCondition indicates an expected call of UniqueCondition.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockOrganizationSettingsRepositoryUniqueConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
+	return &MockOrganizationSettingsRepositoryUniqueConditionCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryUniqueConditionCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryUniqueConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockOrganizationSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockOrganizationSettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UpdatedAtColumn mocks base method.
+func (m *MockOrganizationSettingsRepository) 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 *MockOrganizationSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockOrganizationSettingsRepositoryUpdatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).UpdatedAtColumn))
+	return &MockOrganizationSettingsRepositoryUpdatedAtColumnCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryUpdatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

backend/v3/domain/mock/password_expiry_settings.mock.go

@@ -0,0 +1,932 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: PasswordExpirySettingsRepository)
+//
+// Generated by this command:
+//
+//	mockgen -typed -package domainmock -destination ./mock/password_expiry_settings.mock.go . PasswordExpirySettingsRepository
+//
+
+// 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"
+	json "github.com/zitadel/zitadel/backend/v3/storage/database/json"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockPasswordExpirySettingsRepository is a mock of PasswordExpirySettingsRepository interface.
+type MockPasswordExpirySettingsRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockPasswordExpirySettingsRepositoryMockRecorder
+	isgomock struct{}
+}
+
+// MockPasswordExpirySettingsRepositoryMockRecorder is the mock recorder for MockPasswordExpirySettingsRepository.
+type MockPasswordExpirySettingsRepositoryMockRecorder struct {
+	mock *MockPasswordExpirySettingsRepository
+}
+
+// NewMockPasswordExpirySettingsRepository creates a new mock instance.
+func NewMockPasswordExpirySettingsRepository(ctrl *gomock.Controller) *MockPasswordExpirySettingsRepository {
+	mock := &MockPasswordExpirySettingsRepository{ctrl: ctrl}
+	mock.recorder = &MockPasswordExpirySettingsRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPasswordExpirySettingsRepository) EXPECT() *MockPasswordExpirySettingsRepositoryMockRecorder {
+	return m.recorder
+}
+
+// CreatedAtColumn mocks base method.
+func (m *MockPasswordExpirySettingsRepository) 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 *MockPasswordExpirySettingsRepositoryMockRecorder) CreatedAtColumn() *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).CreatedAtColumn))
+	return &MockPasswordExpirySettingsRepositoryCreatedAtColumnCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryCreatedAtColumnCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryCreatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Delete mocks base method.
+func (m *MockPasswordExpirySettingsRepository) 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 *MockPasswordExpirySettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockPasswordExpirySettingsRepositoryDeleteCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).Delete), ctx, client, condition)
+	return &MockPasswordExpirySettingsRepositoryDeleteCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryDeleteCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryDeleteCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockPasswordExpirySettingsRepositoryDeleteCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockPasswordExpirySettingsRepositoryDeleteCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockPasswordExpirySettingsRepositoryDeleteCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Get mocks base method.
+func (m *MockPasswordExpirySettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.PasswordExpirySettings, 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.PasswordExpirySettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockPasswordExpirySettingsRepositoryGetCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).Get), varargs...)
+	return &MockPasswordExpirySettingsRepositoryGetCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryGetCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryGetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryGetCall) Return(arg0 *domain.PasswordExpirySettings, arg1 error) *MockPasswordExpirySettingsRepositoryGetCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.PasswordExpirySettings, error)) *MockPasswordExpirySettingsRepositoryGetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.PasswordExpirySettings, error)) *MockPasswordExpirySettingsRepositoryGetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDColumn mocks base method.
+func (m *MockPasswordExpirySettingsRepository) 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 *MockPasswordExpirySettingsRepositoryMockRecorder) IDColumn() *MockPasswordExpirySettingsRepositoryIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).IDColumn))
+	return &MockPasswordExpirySettingsRepositoryIDColumnCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryIDColumnCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDCondition mocks base method.
+func (m *MockPasswordExpirySettingsRepository) IDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// IDCondition indicates an expected call of IDCondition.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) IDCondition(id any) *MockPasswordExpirySettingsRepositoryIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).IDCondition), id)
+	return &MockPasswordExpirySettingsRepositoryIDConditionCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryIDConditionCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockPasswordExpirySettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockPasswordExpirySettingsRepositoryIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDColumn mocks base method.
+func (m *MockPasswordExpirySettingsRepository) 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 *MockPasswordExpirySettingsRepositoryMockRecorder) InstanceIDColumn() *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).InstanceIDColumn))
+	return &MockPasswordExpirySettingsRepositoryInstanceIDColumnCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryInstanceIDColumnCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryInstanceIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDCondition mocks base method.
+func (m *MockPasswordExpirySettingsRepository) InstanceIDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InstanceIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// InstanceIDCondition indicates an expected call of InstanceIDCondition.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).InstanceIDCondition), id)
+	return &MockPasswordExpirySettingsRepositoryInstanceIDConditionCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryInstanceIDConditionCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryInstanceIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// List mocks base method.
+func (m *MockPasswordExpirySettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.PasswordExpirySettings, 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.PasswordExpirySettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockPasswordExpirySettingsRepositoryListCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).List), varargs...)
+	return &MockPasswordExpirySettingsRepositoryListCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryListCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryListCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryListCall) Return(arg0 []*domain.PasswordExpirySettings, arg1 error) *MockPasswordExpirySettingsRepositoryListCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.PasswordExpirySettings, error)) *MockPasswordExpirySettingsRepositoryListCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.PasswordExpirySettings, error)) *MockPasswordExpirySettingsRepositoryListCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDColumn mocks base method.
+func (m *MockPasswordExpirySettingsRepository) OrganizationIDColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) OrganizationIDColumn() *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).OrganizationIDColumn))
+	return &MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDCondition mocks base method.
+func (m *MockPasswordExpirySettingsRepository) OrganizationIDCondition(id *string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).OrganizationIDCondition), id)
+	return &MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyColumns mocks base method.
+func (m *MockPasswordExpirySettingsRepository) 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 *MockPasswordExpirySettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).PrimaryKeyColumns))
+	return &MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyCondition mocks base method.
+func (m *MockPasswordExpirySettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
+	return &MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Set mocks base method.
+func (m *MockPasswordExpirySettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.PasswordExpirySettings) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Set", ctx, client, settings)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockPasswordExpirySettingsRepositorySetCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).Set), ctx, client, settings)
+	return &MockPasswordExpirySettingsRepositorySetCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositorySetCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositorySetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositorySetCall) Return(arg0 error) *MockPasswordExpirySettingsRepositorySetCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.PasswordExpirySettings) error) *MockPasswordExpirySettingsRepositorySetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.PasswordExpirySettings) error) *MockPasswordExpirySettingsRepositorySetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetExpireWarnDays mocks base method.
+func (m *MockPasswordExpirySettingsRepository) SetExpireWarnDays(value uint64) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetExpireWarnDays", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetExpireWarnDays indicates an expected call of SetExpireWarnDays.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetExpireWarnDays(value any) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpireWarnDays", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetExpireWarnDays), value)
+	return &MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall) Return(arg0 json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall) Do(f func(uint64) json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetMaxAgeDays mocks base method.
+func (m *MockPasswordExpirySettingsRepository) SetMaxAgeDays(value uint64) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetMaxAgeDays", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetMaxAgeDays indicates an expected call of SetMaxAgeDays.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetMaxAgeDays(value any) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxAgeDays", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetMaxAgeDays), value)
+	return &MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall) Return(arg0 json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall) Do(f func(uint64) json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetSettingFields mocks base method.
+func (m *MockPasswordExpirySettingsRepository) SetSettingFields(value domain.PasswordExpirySettingsAttributes) database.Change {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetSettingFields", value)
+	ret0, _ := ret[0].(database.Change)
+	return ret0
+}
+
+// SetSettingFields indicates an expected call of SetSettingFields.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetSettingFields(value any) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetSettingFields), value)
+	return &MockPasswordExpirySettingsRepositorySetSettingFieldsCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositorySetSettingFieldsCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositorySetSettingFieldsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositorySetSettingFieldsCall) Do(f func(domain.PasswordExpirySettingsAttributes) database.Change) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.PasswordExpirySettingsAttributes) database.Change) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetUpdatedAt mocks base method.
+func (m *MockPasswordExpirySettingsRepository) 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 *MockPasswordExpirySettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetUpdatedAt), updatedAt)
+	return &MockPasswordExpirySettingsRepositorySetUpdatedAtCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositorySetUpdatedAtCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositorySetUpdatedAtCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SettingsColumn mocks base method.
+func (m *MockPasswordExpirySettingsRepository) SettingsColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SettingsColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// SettingsColumn indicates an expected call of SettingsColumn.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SettingsColumn() *MockPasswordExpirySettingsRepositorySettingsColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SettingsColumn))
+	return &MockPasswordExpirySettingsRepositorySettingsColumnCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositorySettingsColumnCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositorySettingsColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// StateColumn mocks base method.
+func (m *MockPasswordExpirySettingsRepository) 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 *MockPasswordExpirySettingsRepositoryMockRecorder) StateColumn() *MockPasswordExpirySettingsRepositoryStateColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).StateColumn))
+	return &MockPasswordExpirySettingsRepositoryStateColumnCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryStateColumnCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryStateColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryStateColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// TypeColumn mocks base method.
+func (m *MockPasswordExpirySettingsRepository) TypeColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// TypeColumn indicates an expected call of TypeColumn.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) TypeColumn() *MockPasswordExpirySettingsRepositoryTypeColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).TypeColumn))
+	return &MockPasswordExpirySettingsRepositoryTypeColumnCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryTypeColumnCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryTypeColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueColumns mocks base method.
+func (m *MockPasswordExpirySettingsRepository) UniqueColumns() []database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueColumns")
+	ret0, _ := ret[0].([]database.Column)
+	return ret0
+}
+
+// UniqueColumns indicates an expected call of UniqueColumns.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) UniqueColumns() *MockPasswordExpirySettingsRepositoryUniqueColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UniqueColumns))
+	return &MockPasswordExpirySettingsRepositoryUniqueColumnsCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryUniqueColumnsCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryUniqueColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockPasswordExpirySettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockPasswordExpirySettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockPasswordExpirySettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueCondition mocks base method.
+func (m *MockPasswordExpirySettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// UniqueCondition indicates an expected call of UniqueCondition.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockPasswordExpirySettingsRepositoryUniqueConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
+	return &MockPasswordExpirySettingsRepositoryUniqueConditionCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryUniqueConditionCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryUniqueConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockPasswordExpirySettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockPasswordExpirySettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UpdatedAtColumn mocks base method.
+func (m *MockPasswordExpirySettingsRepository) 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 *MockPasswordExpirySettingsRepositoryMockRecorder) UpdatedAtColumn() *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UpdatedAtColumn))
+	return &MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

backend/v3/domain/mock/security_settings.mock.go

@@ -0,0 +1,970 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: SecuritySettingsRepository)
+//
+// Generated by this command:
+//
+//	mockgen -typed -package domainmock -destination ./mock/security_settings.mock.go . SecuritySettingsRepository
+//
+
+// 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"
+	json "github.com/zitadel/zitadel/backend/v3/storage/database/json"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockSecuritySettingsRepository is a mock of SecuritySettingsRepository interface.
+type MockSecuritySettingsRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockSecuritySettingsRepositoryMockRecorder
+	isgomock struct{}
+}
+
+// MockSecuritySettingsRepositoryMockRecorder is the mock recorder for MockSecuritySettingsRepository.
+type MockSecuritySettingsRepositoryMockRecorder struct {
+	mock *MockSecuritySettingsRepository
+}
+
+// NewMockSecuritySettingsRepository creates a new mock instance.
+func NewMockSecuritySettingsRepository(ctrl *gomock.Controller) *MockSecuritySettingsRepository {
+	mock := &MockSecuritySettingsRepository{ctrl: ctrl}
+	mock.recorder = &MockSecuritySettingsRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockSecuritySettingsRepository) EXPECT() *MockSecuritySettingsRepositoryMockRecorder {
+	return m.recorder
+}
+
+// CreatedAtColumn mocks base method.
+func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) CreatedAtColumn() *MockSecuritySettingsRepositoryCreatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).CreatedAtColumn))
+	return &MockSecuritySettingsRepositoryCreatedAtColumnCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryCreatedAtColumnCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryCreatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryCreatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Delete mocks base method.
+func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockSecuritySettingsRepositoryDeleteCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).Delete), ctx, client, condition)
+	return &MockSecuritySettingsRepositoryDeleteCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryDeleteCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryDeleteCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockSecuritySettingsRepositoryDeleteCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockSecuritySettingsRepositoryDeleteCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockSecuritySettingsRepositoryDeleteCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Get mocks base method.
+func (m *MockSecuritySettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.SecuritySettings, 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.SecuritySettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockSecuritySettingsRepositoryGetCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).Get), varargs...)
+	return &MockSecuritySettingsRepositoryGetCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryGetCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryGetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryGetCall) Return(arg0 *domain.SecuritySettings, arg1 error) *MockSecuritySettingsRepositoryGetCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.SecuritySettings, error)) *MockSecuritySettingsRepositoryGetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.SecuritySettings, error)) *MockSecuritySettingsRepositoryGetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDColumn mocks base method.
+func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) IDColumn() *MockSecuritySettingsRepositoryIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).IDColumn))
+	return &MockSecuritySettingsRepositoryIDColumnCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryIDColumnCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// IDCondition mocks base method.
+func (m *MockSecuritySettingsRepository) IDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// IDCondition indicates an expected call of IDCondition.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) IDCondition(id any) *MockSecuritySettingsRepositoryIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).IDCondition), id)
+	return &MockSecuritySettingsRepositoryIDConditionCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryIDConditionCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockSecuritySettingsRepositoryIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSecuritySettingsRepositoryIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDColumn mocks base method.
+func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) InstanceIDColumn() *MockSecuritySettingsRepositoryInstanceIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).InstanceIDColumn))
+	return &MockSecuritySettingsRepositoryInstanceIDColumnCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryInstanceIDColumnCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryInstanceIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryInstanceIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// InstanceIDCondition mocks base method.
+func (m *MockSecuritySettingsRepository) InstanceIDCondition(id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InstanceIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// InstanceIDCondition indicates an expected call of InstanceIDCondition.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockSecuritySettingsRepositoryInstanceIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).InstanceIDCondition), id)
+	return &MockSecuritySettingsRepositoryInstanceIDConditionCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryInstanceIDConditionCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryInstanceIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockSecuritySettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSecuritySettingsRepositoryInstanceIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// List mocks base method.
+func (m *MockSecuritySettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.SecuritySettings, 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.SecuritySettings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockSecuritySettingsRepositoryListCall {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, client}, opts...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).List), varargs...)
+	return &MockSecuritySettingsRepositoryListCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryListCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryListCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryListCall) Return(arg0 []*domain.SecuritySettings, arg1 error) *MockSecuritySettingsRepositoryListCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.SecuritySettings, error)) *MockSecuritySettingsRepositoryListCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.SecuritySettings, error)) *MockSecuritySettingsRepositoryListCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDColumn mocks base method.
+func (m *MockSecuritySettingsRepository) OrganizationIDColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) OrganizationIDColumn() *MockSecuritySettingsRepositoryOrganizationIDColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).OrganizationIDColumn))
+	return &MockSecuritySettingsRepositoryOrganizationIDColumnCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryOrganizationIDColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryOrganizationIDColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// OrganizationIDCondition mocks base method.
+func (m *MockSecuritySettingsRepository) OrganizationIDCondition(id *string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrganizationIDCondition", id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockSecuritySettingsRepositoryOrganizationIDConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).OrganizationIDCondition), id)
+	return &MockSecuritySettingsRepositoryOrganizationIDConditionCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryOrganizationIDConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockSecuritySettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockSecuritySettingsRepositoryOrganizationIDConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyColumns mocks base method.
+func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).PrimaryKeyColumns))
+	return &MockSecuritySettingsRepositoryPrimaryKeyColumnsCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryPrimaryKeyColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// PrimaryKeyCondition mocks base method.
+func (m *MockSecuritySettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
+	return &MockSecuritySettingsRepositoryPrimaryKeyConditionCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryPrimaryKeyConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Set mocks base method.
+func (m *MockSecuritySettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.SecuritySettings) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Set", ctx, client, settings)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockSecuritySettingsRepositorySetCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).Set), ctx, client, settings)
+	return &MockSecuritySettingsRepositorySetCall{Call: call}
+}
+
+// MockSecuritySettingsRepositorySetCall wrap *gomock.Call
+type MockSecuritySettingsRepositorySetCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositorySetCall) Return(arg0 error) *MockSecuritySettingsRepositorySetCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.SecuritySettings) error) *MockSecuritySettingsRepositorySetCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.SecuritySettings) error) *MockSecuritySettingsRepositorySetCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetAllowedOrigins mocks base method.
+func (m *MockSecuritySettingsRepository) SetAllowedOrigins(values []string) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetAllowedOrigins", values)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetAllowedOrigins indicates an expected call of SetAllowedOrigins.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) SetAllowedOrigins(values any) *MockSecuritySettingsRepositorySetAllowedOriginsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowedOrigins", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetAllowedOrigins), values)
+	return &MockSecuritySettingsRepositorySetAllowedOriginsCall{Call: call}
+}
+
+// MockSecuritySettingsRepositorySetAllowedOriginsCall wrap *gomock.Call
+type MockSecuritySettingsRepositorySetAllowedOriginsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositorySetAllowedOriginsCall) Return(arg0 json.JsonUpdate) *MockSecuritySettingsRepositorySetAllowedOriginsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositorySetAllowedOriginsCall) Do(f func([]string) json.JsonUpdate) *MockSecuritySettingsRepositorySetAllowedOriginsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositorySetAllowedOriginsCall) DoAndReturn(f func([]string) json.JsonUpdate) *MockSecuritySettingsRepositorySetAllowedOriginsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetEnableIframeEmbedding mocks base method.
+func (m *MockSecuritySettingsRepository) SetEnableIframeEmbedding(value bool) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetEnableIframeEmbedding", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetEnableIframeEmbedding indicates an expected call of SetEnableIframeEmbedding.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) SetEnableIframeEmbedding(value any) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnableIframeEmbedding", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetEnableIframeEmbedding), value)
+	return &MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall{Call: call}
+}
+
+// MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall wrap *gomock.Call
+type MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall) Return(arg0 json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall) Do(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetEnableImpersonation mocks base method.
+func (m *MockSecuritySettingsRepository) SetEnableImpersonation(value bool) json.JsonUpdate {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetEnableImpersonation", value)
+	ret0, _ := ret[0].(json.JsonUpdate)
+	return ret0
+}
+
+// SetEnableImpersonation indicates an expected call of SetEnableImpersonation.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) SetEnableImpersonation(value any) *MockSecuritySettingsRepositorySetEnableImpersonationCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnableImpersonation", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetEnableImpersonation), value)
+	return &MockSecuritySettingsRepositorySetEnableImpersonationCall{Call: call}
+}
+
+// MockSecuritySettingsRepositorySetEnableImpersonationCall wrap *gomock.Call
+type MockSecuritySettingsRepositorySetEnableImpersonationCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositorySetEnableImpersonationCall) Return(arg0 json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableImpersonationCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositorySetEnableImpersonationCall) Do(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableImpersonationCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositorySetEnableImpersonationCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableImpersonationCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetSettingFields mocks base method.
+func (m *MockSecuritySettingsRepository) SetSettingFields(value domain.SecuritySettingsAttributes) database.Change {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetSettingFields", value)
+	ret0, _ := ret[0].(database.Change)
+	return ret0
+}
+
+// SetSettingFields indicates an expected call of SetSettingFields.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) SetSettingFields(value any) *MockSecuritySettingsRepositorySetSettingFieldsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetSettingFields), value)
+	return &MockSecuritySettingsRepositorySetSettingFieldsCall{Call: call}
+}
+
+// MockSecuritySettingsRepositorySetSettingFieldsCall wrap *gomock.Call
+type MockSecuritySettingsRepositorySetSettingFieldsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockSecuritySettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositorySetSettingFieldsCall) Do(f func(domain.SecuritySettingsAttributes) database.Change) *MockSecuritySettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.SecuritySettingsAttributes) database.Change) *MockSecuritySettingsRepositorySetSettingFieldsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetUpdatedAt mocks base method.
+func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockSecuritySettingsRepositorySetUpdatedAtCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetUpdatedAt), updatedAt)
+	return &MockSecuritySettingsRepositorySetUpdatedAtCall{Call: call}
+}
+
+// MockSecuritySettingsRepositorySetUpdatedAtCall wrap *gomock.Call
+type MockSecuritySettingsRepositorySetUpdatedAtCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockSecuritySettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockSecuritySettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockSecuritySettingsRepositorySetUpdatedAtCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SettingsColumn mocks base method.
+func (m *MockSecuritySettingsRepository) SettingsColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SettingsColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// SettingsColumn indicates an expected call of SettingsColumn.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) SettingsColumn() *MockSecuritySettingsRepositorySettingsColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SettingsColumn))
+	return &MockSecuritySettingsRepositorySettingsColumnCall{Call: call}
+}
+
+// MockSecuritySettingsRepositorySettingsColumnCall wrap *gomock.Call
+type MockSecuritySettingsRepositorySettingsColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositorySettingsColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// StateColumn mocks base method.
+func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) StateColumn() *MockSecuritySettingsRepositoryStateColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).StateColumn))
+	return &MockSecuritySettingsRepositoryStateColumnCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryStateColumnCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryStateColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryStateColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryStateColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// TypeColumn mocks base method.
+func (m *MockSecuritySettingsRepository) TypeColumn() database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeColumn")
+	ret0, _ := ret[0].(database.Column)
+	return ret0
+}
+
+// TypeColumn indicates an expected call of TypeColumn.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) TypeColumn() *MockSecuritySettingsRepositoryTypeColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).TypeColumn))
+	return &MockSecuritySettingsRepositoryTypeColumnCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryTypeColumnCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryTypeColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryTypeColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueColumns mocks base method.
+func (m *MockSecuritySettingsRepository) UniqueColumns() []database.Column {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueColumns")
+	ret0, _ := ret[0].([]database.Column)
+	return ret0
+}
+
+// UniqueColumns indicates an expected call of UniqueColumns.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) UniqueColumns() *MockSecuritySettingsRepositoryUniqueColumnsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UniqueColumns))
+	return &MockSecuritySettingsRepositoryUniqueColumnsCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryUniqueColumnsCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryUniqueColumnsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockSecuritySettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockSecuritySettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockSecuritySettingsRepositoryUniqueColumnsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UniqueCondition mocks base method.
+func (m *MockSecuritySettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// UniqueCondition indicates an expected call of UniqueCondition.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockSecuritySettingsRepositoryUniqueConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
+	return &MockSecuritySettingsRepositoryUniqueConditionCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryUniqueConditionCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryUniqueConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockSecuritySettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockSecuritySettingsRepositoryUniqueConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// UpdatedAtColumn mocks base method.
+func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) UpdatedAtColumn() *MockSecuritySettingsRepositoryUpdatedAtColumnCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UpdatedAtColumn))
+	return &MockSecuritySettingsRepositoryUpdatedAtColumnCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryUpdatedAtColumnCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryUpdatedAtColumnCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}

backend/v3/domain/session_check_password.go

@@ -0,0 +1,340 @@
+package domain
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/muhlemmer/gu"
+	"github.com/zitadel/passwap"
+
+	"github.com/zitadel/zitadel/backend/v3/storage/database"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/repository/session"
+	"github.com/zitadel/zitadel/internal/repository/user"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+// tarpitFn represents a tarpit function
+//
+// The input is the number of failed attempts after which the tarpit is started
+type tarpitFn func(failedAttempts uint64)
+
+type CheckPasswordType struct {
+	Password string
+}
+
+type PasswordCheckCommand struct {
+	CheckPassword *CheckPasswordType
+
+	SessionID  string
+	InstanceID string
+	TarpitFunc tarpitFn
+	VerifierFn func(encoded, password string) (updated string, err error)
+
+	FetchedUser      User
+	UpdatedHashedPsw string
+	CheckTime        time.Time
+
+	// IsValidated indicates if the password check has completed (no transaction errors)
+	IsValidated bool
+
+	// IsValidationSuccessful indicates if the completed password check is successful
+	// (i.e. no functional error is returned)
+	IsValidationSuccessful bool
+
+	// IsUserLocked indicates if the user has been locked (i.e. lockout policy check failed)
+	IsUserLocked bool
+}
+
+// NewPasswordCheckCommand initializes a new [PasswordCheckCommand]
+//
+// If tarpitFunc is nil, the default tarpit will be used.
+//
+// verifyFn is a function that takes as input a target encoded password
+// and an input password to verify. It returns an updated hash and an error.
+// It defaults to [passwap.Swapper.Verify]
+//
+// The command does not implement [Transactional] due verifyFn that might take a long time to execute.
+// So the DB transaction will be started only after verifyFn has been run.
+//
+// Moreover, the command may return a functional error so manual management of the transaction is needed
+// to avoid rollbacking a transaction despite having only a functional error.
+func NewPasswordCheckCommand(sessionID, instanceID string, tarpitFunc tarpitFn, verifyFn func(encoded, password string) (updated string, err error), request *CheckPasswordType) *PasswordCheckCommand {
+	tf := sysConfig.Tarpit.Tarpit()
+	if tarpitFunc != nil {
+		tf = tarpitFunc
+	}
+
+	verifierFunction := passwordHasher.Verify
+	if verifyFn != nil {
+		verifierFunction = verifyFn
+	}
+
+	return &PasswordCheckCommand{
+		CheckPassword: request,
+		SessionID:     strings.TrimSpace(sessionID),
+		InstanceID:    strings.TrimSpace(instanceID),
+		TarpitFunc:    tf,
+		VerifierFn:    verifierFunction,
+	}
+}
+
+// Events implements [Commander].
+func (p *PasswordCheckCommand) Events(ctx context.Context, opts *InvokeOpts) ([]eventstore.Command, error) {
+	if p.CheckPassword == nil || !p.IsValidated {
+		return nil, nil
+	}
+
+	toReturn := make([]eventstore.Command, 1, 3)
+	userAgg := &user.NewAggregate(p.FetchedUser.ID, p.FetchedUser.OrganizationID).Aggregate
+
+	if p.IsValidationSuccessful {
+		toReturn[0] = user.NewHumanPasswordCheckSucceededEvent(ctx, userAgg, nil)
+		if p.UpdatedHashedPsw != "" {
+			toReturn = append(toReturn, user.NewHumanPasswordHashUpdatedEvent(ctx, userAgg, p.UpdatedHashedPsw))
+		}
+	} else {
+		toReturn[0] = user.NewHumanPasswordCheckFailedEvent(ctx, userAgg, nil)
+		if p.IsUserLocked {
+			toReturn = append(toReturn, user.NewUserLockedEvent(ctx, userAgg))
+		}
+	}
+
+	toReturn = append(toReturn, session.NewPasswordCheckedEvent(ctx, &session.NewAggregate(p.SessionID, p.InstanceID).Aggregate, p.CheckTime))
+
+	return toReturn, nil
+}
+
+// Execute implements [Commander].
+func (p *PasswordCheckCommand) Execute(ctx context.Context, opts *InvokeOpts) (err error) {
+	if p.CheckPassword == nil {
+		return nil
+	}
+
+	humanRepo := opts.userRepo.Human()
+	sessionRepo := opts.sessionRepo
+
+	updatedHash, verifyErr := p.VerifierFn(p.FetchedUser.Human.Password.Hash, p.CheckPassword.Password)
+	pswCheckType, err := p.GetPasswordCheckAndError(verifyErr)
+	changes, changesErr := p.GetPasswordCheckChanges(ctx, opts, humanRepo, updatedHash, pswCheckType)
+	if changesErr != nil {
+		return changesErr
+	}
+	beginner, ok := opts.DB().(database.Beginner)
+	if !ok {
+		return zerrors.ThrowInternal(nil, "DOM-fEhd79", "database doesn't implement database.Beginner")
+	}
+
+	tx, txErr := beginner.Begin(ctx, nil)
+	if txErr != nil {
+		return zerrors.ThrowInternal(txErr, "DOM-IR1vH2", "failed starting transaction")
+	}
+
+	defer func() {
+		if endErr := tx.End(ctx, txErr); endErr != nil {
+			err = endErr
+		}
+	}()
+
+	updateCount, updateErr := humanRepo.Update(
+		ctx,
+		tx,
+
+		humanRepo.IDCondition(p.FetchedUser.ID),
+
+		changes,
+	)
+	if updateErr != nil {
+		txErr = zerrors.ThrowInternal(updateErr, "DOM-netNam", "failed updating user")
+		return txErr
+	}
+
+	if updateCount == 0 {
+		txErr = zerrors.ThrowNotFound(nil, "DOM-8wVrNc", "user not found")
+		return txErr
+	}
+	if updateCount > 1 {
+		txErr = zerrors.ThrowInternal(NewMultipleObjectsUpdatedError(1, updateCount), "DOM-D4hy9C", "unexpected number of rows updated")
+		return txErr
+	}
+
+	var passwordFactor SessionFactor
+	if err == nil {
+		passwordFactor = &SessionFactorPassword{LastVerifiedAt: p.CheckTime}
+	} else {
+		passwordFactor = &SessionFactorPassword{LastFailedAt: p.CheckTime}
+	}
+
+	updateCount, updateErr = sessionRepo.Update(ctx, tx, sessionRepo.IDCondition(p.SessionID), sessionRepo.SetFactor(passwordFactor))
+	if updateErr != nil {
+		txErr = zerrors.ThrowInternal(updateErr, "DOM-IZagay", "failed updating session")
+		return txErr
+	}
+
+	if updateCount == 0 {
+		txErr = zerrors.ThrowNotFound(nil, "DOM-H9Q59c", "session not found")
+		return txErr
+	}
+	if updateCount > 1 {
+		txErr = zerrors.ThrowInternal(NewMultipleObjectsUpdatedError(1, updateCount), "DOM-Tbvpy8", "unexpected number of rows updated")
+		return txErr
+	}
+
+	if err != nil && p.TarpitFunc != nil {
+		p.TarpitFunc(uint64(p.FetchedUser.Human.Password.FailedAttempts + 1))
+	}
+
+	p.IsValidated = true
+	p.IsValidationSuccessful = err == nil
+
+	// This error is functional so it should be returned AND the transaction should succeed.
+	// Hence, do not use [Transactional] and make sure txErr = nil
+	return err
+}
+
+func (p *PasswordCheckCommand) getLockoutPolicy(ctx context.Context, opts *InvokeOpts, orgID string) (*LockoutSettings, error) {
+	lockoutSettingRepo := opts.lockoutSettingRepo
+
+	// We need the organization lockout policy first, and if not available, the instance (default) policy.
+	// So we retrieve all records with a matching instance ID and organization ID OR
+	// all records with a matching instance ID and NULL (or empty) organization ID.
+	// Then we assume NULLs are sorted as largest numbers (that's the case in Postgres),
+	// so we sort ascending by organization ID.
+	// We limit the result to 1 so that we get either the org policy or the instance one.
+	settings, err := lockoutSettingRepo.List(ctx, opts.DB(),
+		p.listLockoutSettingCondition(lockoutSettingRepo, orgID),
+		database.WithOrderByAscending(lockoutSettingRepo.OrganizationIDColumn(), lockoutSettingRepo.InstanceIDColumn()),
+		database.WithLimit(1),
+	)
+	if err != nil {
+		return nil, zerrors.ThrowInternal(err, "DOM-3B8Z6s", "failed fetching lockout settings")
+	}
+
+	if rowsReturned := len(settings); rowsReturned != 1 {
+		return nil, zerrors.ThrowInternal(NewRowsReturnedMismatchError(1, int64(rowsReturned)), "DOM-mmsrCt", "unexpected number of rows returned")
+	}
+
+	return settings[0], nil
+}
+
+func (p *PasswordCheckCommand) listLockoutSettingCondition(repo LockoutSettingsRepository, orgID string) database.QueryOption {
+	instanceAndOrg := database.And(repo.InstanceIDCondition(p.InstanceID), repo.OrganizationIDCondition(&orgID))
+	orgNullOrEmpty := database.Or(repo.OrganizationIDCondition(nil), repo.OrganizationIDCondition(gu.Ptr("")))
+	onlyInstance := database.And(repo.InstanceIDCondition(p.InstanceID), orgNullOrEmpty)
+
+	return database.WithCondition(database.Or(instanceAndOrg, onlyInstance))
+}
+
+func (p *PasswordCheckCommand) GetPasswordCheckChanges(ctx context.Context, opts *InvokeOpts, humanRepo HumanUserRepository, updatedHash string, checkType VerificationType) (database.Changes, error) {
+	dbUpdates := make(database.Changes, 1)
+	switch ct := checkType.(type) {
+	case *VerificationTypeSucceeded:
+		dbUpdates[0] = humanRepo.SetLastSuccessfulPasswordCheck(ct.VerifiedAt)
+		if updatedHash != "" {
+			p.UpdatedHashedPsw = updatedHash
+			dbUpdates = append(dbUpdates, humanRepo.SetPassword(updatedHash))
+		}
+	case *VerificationTypeFailed:
+		dbUpdates[0] = humanRepo.IncrementPasswordFailedAttempts()
+		lockoutPolicy, err := p.getLockoutPolicy(ctx, opts, p.FetchedUser.OrganizationID)
+		if err != nil {
+			return nil, err
+		}
+
+		if lockoutPolicy != nil &&
+			lockoutPolicy.MaxPasswordAttempts != nil && *lockoutPolicy.MaxPasswordAttempts > 0 &&
+			uint64(p.FetchedUser.Human.Password.FailedAttempts+1) >= *lockoutPolicy.MaxPasswordAttempts {
+
+			dbUpdates = append(dbUpdates, humanRepo.SetState(UserStateLocked))
+			p.IsUserLocked = true
+		}
+	}
+
+	return dbUpdates, nil
+}
+
+func (p *PasswordCheckCommand) GetPasswordCheckAndError(err error) (VerificationType, error) {
+	p.CheckTime = time.Now()
+	if err == nil {
+		return &VerificationTypeSucceeded{VerifiedAt: p.CheckTime}, nil
+	}
+
+	// TODO(IAM-Marco): Do we actually want to differentiate? I feel that it's giving away relevant info
+	// about the password
+	if errors.Is(err, passwap.ErrPasswordMismatch) {
+		err = zerrors.ThrowInvalidArgument(
+			NewPasswordVerificationError(p.FetchedUser.Human.Password.FailedAttempts+1),
+			"DOM-3gcfDV",
+			"Errors.User.Password.Invalid",
+		)
+		return &VerificationTypeFailed{FailedAt: p.CheckTime}, err
+	}
+
+	return &VerificationTypeFailed{FailedAt: p.CheckTime}, zerrors.ThrowInternal(err, "DOM-xceNzI", "Errors.Internal")
+}
+
+// String implements [Commander].
+func (p *PasswordCheckCommand) String() string {
+	return "PasswordCheckCommand"
+}
+
+// Validate implements [Commander].
+func (p *PasswordCheckCommand) Validate(ctx context.Context, opts *InvokeOpts) (err error) {
+	if p.CheckPassword == nil {
+		return nil
+	}
+
+	if p.SessionID == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "DOM-cRKWNx", "Errors.Missing.SessionID")
+	}
+	if p.InstanceID == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "DOM-JnEtcJ", "Errors.Missing.InstanceID")
+	}
+
+	sessionRepo := opts.sessionRepo
+	userRepo := opts.userRepo
+
+	session, err := sessionRepo.Get(ctx, opts.DB(), database.WithCondition(sessionRepo.IDCondition(p.SessionID)))
+	if err != nil {
+		if errors.Is(err, &database.NoRowFoundError{}) {
+			return zerrors.ThrowNotFound(err, "DOM-0XRmp8", "session not found")
+		}
+		return zerrors.ThrowInternal(err, "DOM-qAoQrg", "failed fetching session")
+	}
+
+	if session.UserID == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "DOM-hord0Z", "Errors.User.UserIDMissing")
+	}
+
+	user, err := userRepo.Get(ctx, opts.DB(), database.WithCondition(userRepo.IDCondition(session.UserID)))
+	if err != nil {
+		if errors.Is(err, &database.NoRowFoundError{}) {
+			return zerrors.ThrowNotFound(err, "DOM-zxKosn", "Errors.User.NotFound")
+		}
+		return zerrors.ThrowInternal(err, "DOM-nKD4Gq", "failed fetching user")
+	}
+	if user.Human == nil {
+		return zerrors.ThrowPreconditionFailed(nil, "DOM-ADhxAx", "user not human")
+	}
+	human := user.Human
+
+	if user.State == UserStateLocked {
+		return zerrors.ThrowPreconditionFailedf(
+			NewPasswordVerificationError(user.Human.Password.FailedAttempts),
+			"DOM-D804Sj",
+			"Errors.User.Locked",
+		)
+	}
+
+	if human.Password.Hash == "" {
+		return zerrors.ThrowPreconditionFailed(nil, "DOM-gklgos", "Errors.User.Password.NotSet")
+	}
+
+	p.FetchedUser = *user
+
+	return nil
+}
+
+var _ Commander = (*PasswordCheckCommand)(nil)

backend/v3/domain/settings.go

@@ -162,6 +162,7 @@ type LoginSettingsAttributes struct {
 	SecondFactorTypes []SecondFactorType `json:"secondFactors,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/login_settings.mock.go . LoginSettingsRepository
 type LoginSettingsRepository interface {
 	settingsRepository[LoginSettings]
 	loginSettingsJSONChanges
@@ -228,6 +229,7 @@ type BrandingSettingsAttributes struct {
 	FontURL             *url.URL                 `json:"fontUrl,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/branding_settings.mock.go . BrandingSettingsRepository
 type BrandingSettingsRepository interface {
 	settingsRepository[BrandingSettings]
 	brandingSettingsJSONChanges
@@ -261,6 +263,7 @@ type PasswordComplexitySettingsAttributes struct {
 	HasSymbol    *bool   `json:"hasSymbol,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/password_complexity_settings.mock.go . PasswordComplexitySettingsRepository
 type PasswordComplexitySettingsRepository interface {
 	settingsRepository[PasswordComplexitySettings]
 	passwordComplexitySettingsJSONChanges
@@ -283,6 +286,7 @@ type PasswordExpirySettingsAttributes struct {
 	MaxAgeDays     *uint64 `json:"maxAgeDays,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/password_expiry_settings.mock.go . PasswordExpirySettingsRepository
 type PasswordExpirySettingsRepository interface {
 	settingsRepository[PasswordExpirySettings]
 	passwordExpirySettingsJSONChanges
@@ -307,6 +311,7 @@ type LockoutSettingsAttributes struct {
 	ShowLockOutFailures *bool   `json:"showLockOutFailures,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/lockout_settings.mock.go . LockoutSettingsRepository
 type LockoutSettingsRepository interface {
 	settingsRepository[LockoutSettings]
 	lockoutSettingsJSONChanges
@@ -331,6 +336,7 @@ type SecuritySettingsAttributes struct {
 	EnableImpersonation   *bool    `json:"enableImpersonation,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/security_settings.mock.go . SecuritySettingsRepository
 type SecuritySettingsRepository interface {
 	settingsRepository[SecuritySettings]
 	securitySettingsJSONChanges
@@ -354,6 +360,7 @@ type DomainSettingsAttributes struct {
 	SMTPSenderAddressMatchesInstanceDomain *bool `json:"smtpSenderAddressMatchesInstanceDomain,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/domain_settings.mock.go . DomainSettingsRepository
 type DomainSettingsRepository interface {
 	settingsRepository[DomainSettings]
 	domainSettingsJSONChanges
@@ -373,6 +380,7 @@ type OrganizationSettingsAttributes struct {
 	OrganizationScopedUsernames *bool `json:"organizationScopedUsernames,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/organization_settings.mock.go . OrganizationSettingsRepository
 type OrganizationSettingsRepository interface {
 	settingsRepository[OrganizationSettings]
 	organizationSettingsJSONChanges
@@ -393,6 +401,7 @@ type NotificationSettingsAttributes struct {
 	PasswordChange *bool `json:"passwordChange,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/notification_settings.mock.go . NotificationSettingsRepository
 type NotificationSettingsRepository interface {
 	settingsRepository[NotificationSettings]
 	notificationSettingsJSONChanges
@@ -425,6 +434,7 @@ type LegalAndSupportSettingsAttributes struct {
 	CustomLinkText    *string `json:"customLinkText,omitempty"`
 }
 
+//go:generate mockgen -typed -package domainmock -destination ./mock/legal_and_support_settings.mock.go . LegalAndSupportSettingsRepository
 type LegalAndSupportSettingsRepository interface {
 	settingsRepository[LegalAndSupportSettings]
 	legalAndSupportSettingsJSONChanges

cmd/start/start.go

@@ -208,6 +208,7 @@ func startZitadel(ctx context.Context, config *Config, masterKey string, server
 	}))
 
 	new_domain.SetLegacyEventstore(eventstoreClient)
+	new_domain.SetSystemConfig(config.SystemDefaults)
 
 	sessionTokenVerifier := internal_authz.SessionTokenVerifier(keys.OIDC)
 	cacheConnectors, err := connector.StartConnectors(config.Caches, dbClient)

internal/command/command.go

@@ -19,6 +19,7 @@ import (
 	"github.com/go-jose/go-jose/v4"
 	"github.com/zitadel/logging"
 
+	new_domain "github.com/zitadel/zitadel/backend/v3/domain"
 	"github.com/zitadel/zitadel/internal/api/authz"
 	api_http "github.com/zitadel/zitadel/internal/api/http"
 	"github.com/zitadel/zitadel/internal/cache/connector"
@@ -152,6 +153,9 @@ func StartCommands(
 	if err != nil {
 		return nil, fmt.Errorf("password hasher: %w", err)
 	}
+
+	new_domain.SetPasswordHasher(userPasswordHasher)
+
 	caches, err := startCaches(ctx, cacheConnectors)
 	if err != nil {
 		return nil, fmt.Errorf("caches: %w", err)