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

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

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

// MockLoginSettingsRepository is a mock of LoginSettingsRepository interface.
type MockLoginSettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockLoginSettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockLoginSettingsRepositoryMockRecorder is the mock recorder for MockLoginSettingsRepository.
type MockLoginSettingsRepositoryMockRecorder struct {
	mock *MockLoginSettingsRepository
}

// NewMockLoginSettingsRepository creates a new mock instance.
func NewMockLoginSettingsRepository(ctrl *gomock.Controller) *MockLoginSettingsRepository {
	mock := &MockLoginSettingsRepository{ctrl: ctrl}
	mock.recorder = &MockLoginSettingsRepositoryMockRecorder{mock}
	return mock
}

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

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

// AddMFAType indicates an expected call of AddMFAType.
func (mr *MockLoginSettingsRepositoryMockRecorder) AddMFAType(value any) *MockLoginSettingsRepositoryAddMFATypeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMFAType", reflect.TypeOf((*MockLoginSettingsRepository)(nil).AddMFAType), value)
	return &MockLoginSettingsRepositoryAddMFATypeCall{Call: call}
}

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

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

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

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

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

// AddSecondFactorTypes indicates an expected call of AddSecondFactorTypes.
func (mr *MockLoginSettingsRepositoryMockRecorder) AddSecondFactorTypes(value any) *MockLoginSettingsRepositoryAddSecondFactorTypesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSecondFactorTypes", reflect.TypeOf((*MockLoginSettingsRepository)(nil).AddSecondFactorTypes), value)
	return &MockLoginSettingsRepositoryAddSecondFactorTypesCall{Call: call}
}

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

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

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

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

// CreatedAtColumn mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) CreatedAtColumn() *MockLoginSettingsRepositoryCreatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).CreatedAtColumn))
	return &MockLoginSettingsRepositoryCreatedAtColumnCall{Call: call}
}

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

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

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

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

// Delete mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockLoginSettingsRepositoryDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLoginSettingsRepository)(nil).Delete), ctx, client, condition)
	return &MockLoginSettingsRepositoryDeleteCall{Call: call}
}

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

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

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

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

// Get mocks base method.
func (m *MockLoginSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.LoginSettings, 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.LoginSettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockLoginSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockLoginSettingsRepositoryGetCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLoginSettingsRepository)(nil).Get), varargs...)
	return &MockLoginSettingsRepositoryGetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositoryGetCall) Return(arg0 *domain.LoginSettings, arg1 error) *MockLoginSettingsRepositoryGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LoginSettings, error)) *MockLoginSettingsRepositoryGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LoginSettings, error)) *MockLoginSettingsRepositoryGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IDColumn mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) IDColumn() *MockLoginSettingsRepositoryIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).IDColumn))
	return &MockLoginSettingsRepositoryIDColumnCall{Call: call}
}

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

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

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

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

// IDCondition mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) IDCondition(id any) *MockLoginSettingsRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).IDCondition), id)
	return &MockLoginSettingsRepositoryIDConditionCall{Call: call}
}

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

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

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

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

// InstanceIDColumn mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) InstanceIDColumn() *MockLoginSettingsRepositoryInstanceIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).InstanceIDColumn))
	return &MockLoginSettingsRepositoryInstanceIDColumnCall{Call: call}
}

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

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

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

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

// InstanceIDCondition mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockLoginSettingsRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).InstanceIDCondition), id)
	return &MockLoginSettingsRepositoryInstanceIDConditionCall{Call: call}
}

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

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

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

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

// List mocks base method.
func (m *MockLoginSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.LoginSettings, 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.LoginSettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockLoginSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockLoginSettingsRepositoryListCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLoginSettingsRepository)(nil).List), varargs...)
	return &MockLoginSettingsRepositoryListCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositoryListCall) Return(arg0 []*domain.LoginSettings, arg1 error) *MockLoginSettingsRepositoryListCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LoginSettings, error)) *MockLoginSettingsRepositoryListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LoginSettings, error)) *MockLoginSettingsRepositoryListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OrganizationIDColumn mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockLoginSettingsRepositoryOrganizationIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).OrganizationIDColumn))
	return &MockLoginSettingsRepositoryOrganizationIDColumnCall{Call: call}
}

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

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

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

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

// OrganizationIDCondition mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockLoginSettingsRepositoryOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).OrganizationIDCondition), id)
	return &MockLoginSettingsRepositoryOrganizationIDConditionCall{Call: call}
}

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

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

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

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

// PrimaryKeyColumns mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockLoginSettingsRepositoryPrimaryKeyColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockLoginSettingsRepository)(nil).PrimaryKeyColumns))
	return &MockLoginSettingsRepositoryPrimaryKeyColumnsCall{Call: call}
}

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

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

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

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

// PrimaryKeyCondition mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockLoginSettingsRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
	return &MockLoginSettingsRepositoryPrimaryKeyConditionCall{Call: call}
}

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

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

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

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

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

// RemoveMFAType indicates an expected call of RemoveMFAType.
func (mr *MockLoginSettingsRepositoryMockRecorder) RemoveMFAType(value any) *MockLoginSettingsRepositoryRemoveMFATypeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMFAType", reflect.TypeOf((*MockLoginSettingsRepository)(nil).RemoveMFAType), value)
	return &MockLoginSettingsRepositoryRemoveMFATypeCall{Call: call}
}

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

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

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

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

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

// RemoveSecondFactorTypes indicates an expected call of RemoveSecondFactorTypes.
func (mr *MockLoginSettingsRepositoryMockRecorder) RemoveSecondFactorTypes(value any) *MockLoginSettingsRepositoryRemoveSecondFactorTypesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSecondFactorTypes", reflect.TypeOf((*MockLoginSettingsRepository)(nil).RemoveSecondFactorTypes), value)
	return &MockLoginSettingsRepositoryRemoveSecondFactorTypesCall{Call: call}
}

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

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

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

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

// Set mocks base method.
func (m *MockLoginSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.LoginSettings) 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 *MockLoginSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockLoginSettingsRepositorySetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockLoginSettingsRepository)(nil).Set), ctx, client, settings)
	return &MockLoginSettingsRepositorySetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetCall) Return(arg0 error) *MockLoginSettingsRepositorySetCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.LoginSettings) error) *MockLoginSettingsRepositorySetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.LoginSettings) error) *MockLoginSettingsRepositorySetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetAllowDomainDiscovery mocks base method.
func (m *MockLoginSettingsRepository) SetAllowDomainDiscovery(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAllowDomainDiscovery", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetAllowDomainDiscovery indicates an expected call of SetAllowDomainDiscovery.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetAllowDomainDiscovery(value any) *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowDomainDiscovery", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetAllowDomainDiscovery), value)
	return &MockLoginSettingsRepositorySetAllowDomainDiscoveryCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetAllowExternalIDP mocks base method.
func (m *MockLoginSettingsRepository) SetAllowExternalIDP(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAllowExternalIDP", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetAllowExternalIDP indicates an expected call of SetAllowExternalIDP.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetAllowExternalIDP(value any) *MockLoginSettingsRepositorySetAllowExternalIDPCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowExternalIDP", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetAllowExternalIDP), value)
	return &MockLoginSettingsRepositorySetAllowExternalIDPCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetAllowExternalIDPCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetAllowExternalIDPCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetAllowExternalIDPCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowExternalIDPCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetAllowExternalIDPCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowExternalIDPCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetAllowRegister mocks base method.
func (m *MockLoginSettingsRepository) SetAllowRegister(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAllowRegister", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetAllowRegister indicates an expected call of SetAllowRegister.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetAllowRegister(value any) *MockLoginSettingsRepositorySetAllowRegisterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowRegister", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetAllowRegister), value)
	return &MockLoginSettingsRepositorySetAllowRegisterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetAllowRegisterCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetAllowRegisterCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetAllowRegisterCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowRegisterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetAllowRegisterCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowRegisterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetAllowUserNamePassword mocks base method.
func (m *MockLoginSettingsRepository) SetAllowUserNamePassword(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAllowUserNamePassword", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetAllowUserNamePassword indicates an expected call of SetAllowUserNamePassword.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetAllowUserNamePassword(value any) *MockLoginSettingsRepositorySetAllowUserNamePasswordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowUserNamePassword", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetAllowUserNamePassword), value)
	return &MockLoginSettingsRepositorySetAllowUserNamePasswordCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetAllowUserNamePasswordCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetAllowUserNamePasswordCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetAllowUserNamePasswordCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowUserNamePasswordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetAllowUserNamePasswordCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowUserNamePasswordCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetColumns mocks base method.
func (m *MockLoginSettingsRepository) SetColumns(ctx context.Context, client database.QueryExecutor, settings *domain.Settings, changes ...database.Change) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client, settings}
	for _, a := range changes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetColumns", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetColumns indicates an expected call of SetColumns.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetColumns(ctx, client, settings any, changes ...any) *MockLoginSettingsRepositorySetColumnsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, settings}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetColumns", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetColumns), varargs...)
	return &MockLoginSettingsRepositorySetColumnsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetColumnsCall) Return(arg0 error) *MockLoginSettingsRepositorySetColumnsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetColumnsCall) Do(f func(context.Context, database.QueryExecutor, *domain.Settings, ...database.Change) error) *MockLoginSettingsRepositorySetColumnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetColumnsCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.Settings, ...database.Change) error) *MockLoginSettingsRepositorySetColumnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetDefaultRedirectURI indicates an expected call of SetDefaultRedirectURI.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetDefaultRedirectURI(value any) *MockLoginSettingsRepositorySetDefaultRedirectURICall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultRedirectURI", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetDefaultRedirectURI), value)
	return &MockLoginSettingsRepositorySetDefaultRedirectURICall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetDefaultRedirectURICall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetDefaultRedirectURICall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetDefaultRedirectURICall) Do(f func(string) json.JsonUpdate) *MockLoginSettingsRepositorySetDefaultRedirectURICall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetDefaultRedirectURICall) DoAndReturn(f func(string) json.JsonUpdate) *MockLoginSettingsRepositorySetDefaultRedirectURICall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetDisableLoginWithEmail mocks base method.
func (m *MockLoginSettingsRepository) SetDisableLoginWithEmail(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDisableLoginWithEmail", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetDisableLoginWithEmail indicates an expected call of SetDisableLoginWithEmail.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetDisableLoginWithEmail(value any) *MockLoginSettingsRepositorySetDisableLoginWithEmailCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDisableLoginWithEmail", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetDisableLoginWithEmail), value)
	return &MockLoginSettingsRepositorySetDisableLoginWithEmailCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetDisableLoginWithEmailCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithEmailCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetDisableLoginWithEmailCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithEmailCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetDisableLoginWithEmailCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithEmailCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetDisableLoginWithPhone mocks base method.
func (m *MockLoginSettingsRepository) SetDisableLoginWithPhone(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDisableLoginWithPhone", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetDisableLoginWithPhone indicates an expected call of SetDisableLoginWithPhone.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetDisableLoginWithPhone(value any) *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDisableLoginWithPhone", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetDisableLoginWithPhone), value)
	return &MockLoginSettingsRepositorySetDisableLoginWithPhoneCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetExternalLoginCheckLifetime mocks base method.
func (m *MockLoginSettingsRepository) SetExternalLoginCheckLifetime(value time.Duration) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetExternalLoginCheckLifetime", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetExternalLoginCheckLifetime indicates an expected call of SetExternalLoginCheckLifetime.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetExternalLoginCheckLifetime(value any) *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExternalLoginCheckLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetExternalLoginCheckLifetime), value)
	return &MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetForceMFA mocks base method.
func (m *MockLoginSettingsRepository) SetForceMFA(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetForceMFA", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetForceMFA indicates an expected call of SetForceMFA.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetForceMFA(value any) *MockLoginSettingsRepositorySetForceMFACall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetForceMFA", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetForceMFA), value)
	return &MockLoginSettingsRepositorySetForceMFACall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetForceMFACall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFACall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetForceMFACall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFACall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetForceMFACall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFACall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetForceMFALocalOnly mocks base method.
func (m *MockLoginSettingsRepository) SetForceMFALocalOnly(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetForceMFALocalOnly", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetForceMFALocalOnly indicates an expected call of SetForceMFALocalOnly.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetForceMFALocalOnly(value any) *MockLoginSettingsRepositorySetForceMFALocalOnlyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetForceMFALocalOnly", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetForceMFALocalOnly), value)
	return &MockLoginSettingsRepositorySetForceMFALocalOnlyCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetForceMFALocalOnlyCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFALocalOnlyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetForceMFALocalOnlyCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFALocalOnlyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetForceMFALocalOnlyCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFALocalOnlyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetHidePasswordReset mocks base method.
func (m *MockLoginSettingsRepository) SetHidePasswordReset(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHidePasswordReset", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetHidePasswordReset indicates an expected call of SetHidePasswordReset.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetHidePasswordReset(value any) *MockLoginSettingsRepositorySetHidePasswordResetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHidePasswordReset", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetHidePasswordReset), value)
	return &MockLoginSettingsRepositorySetHidePasswordResetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetHidePasswordResetCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetHidePasswordResetCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetHidePasswordResetCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetHidePasswordResetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetHidePasswordResetCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetHidePasswordResetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetIgnoreUnknownUsernames mocks base method.
func (m *MockLoginSettingsRepository) SetIgnoreUnknownUsernames(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIgnoreUnknownUsernames", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetIgnoreUnknownUsernames indicates an expected call of SetIgnoreUnknownUsernames.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetIgnoreUnknownUsernames(value any) *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIgnoreUnknownUsernames", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetIgnoreUnknownUsernames), value)
	return &MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetMFAInitSkipLifetime mocks base method.
func (m *MockLoginSettingsRepository) SetMFAInitSkipLifetime(value time.Duration) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMFAInitSkipLifetime", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetMFAInitSkipLifetime indicates an expected call of SetMFAInitSkipLifetime.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetMFAInitSkipLifetime(value any) *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMFAInitSkipLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetMFAInitSkipLifetime), value)
	return &MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetMultiFactorCheckLifetime mocks base method.
func (m *MockLoginSettingsRepository) SetMultiFactorCheckLifetime(value time.Duration) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMultiFactorCheckLifetime", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetMultiFactorCheckLifetime indicates an expected call of SetMultiFactorCheckLifetime.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetMultiFactorCheckLifetime(value any) *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMultiFactorCheckLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetMultiFactorCheckLifetime), value)
	return &MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasswordCheckLifetime mocks base method.
func (m *MockLoginSettingsRepository) SetPasswordCheckLifetime(value time.Duration) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasswordCheckLifetime", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetPasswordCheckLifetime indicates an expected call of SetPasswordCheckLifetime.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetPasswordCheckLifetime(value any) *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordCheckLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetPasswordCheckLifetime), value)
	return &MockLoginSettingsRepositorySetPasswordCheckLifetimeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasswordlessType mocks base method.
func (m *MockLoginSettingsRepository) SetPasswordlessType(value domain.PasswordlessType) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasswordlessType", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetPasswordlessType indicates an expected call of SetPasswordlessType.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetPasswordlessType(value any) *MockLoginSettingsRepositorySetPasswordlessTypeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordlessType", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetPasswordlessType), value)
	return &MockLoginSettingsRepositorySetPasswordlessTypeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetPasswordlessTypeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordlessTypeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetPasswordlessTypeCall) Do(f func(domain.PasswordlessType) json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordlessTypeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetPasswordlessTypeCall) DoAndReturn(f func(domain.PasswordlessType) json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordlessTypeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetSecondFactorCheckLifetime mocks base method.
func (m *MockLoginSettingsRepository) SetSecondFactorCheckLifetime(value time.Duration) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSecondFactorCheckLifetime", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetSecondFactorCheckLifetime indicates an expected call of SetSecondFactorCheckLifetime.
func (mr *MockLoginSettingsRepositoryMockRecorder) SetSecondFactorCheckLifetime(value any) *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecondFactorCheckLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetSecondFactorCheckLifetime), value)
	return &MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetSettingFields mocks base method.
func (m *MockLoginSettingsRepository) SetSettingFields(value domain.LoginSettingsAttributes) 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 *MockLoginSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockLoginSettingsRepositorySetSettingFieldsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetSettingFields), value)
	return &MockLoginSettingsRepositorySetSettingFieldsCall{Call: call}
}

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

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

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

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

// SetUpdatedAt mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockLoginSettingsRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetUpdatedAt), updatedAt)
	return &MockLoginSettingsRepositorySetUpdatedAtCall{Call: call}
}

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

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

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

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

// SettingsColumn mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) SettingsColumn() *MockLoginSettingsRepositorySettingsColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SettingsColumn))
	return &MockLoginSettingsRepositorySettingsColumnCall{Call: call}
}

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

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

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

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

// StateColumn mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) StateColumn() *MockLoginSettingsRepositoryStateColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).StateColumn))
	return &MockLoginSettingsRepositoryStateColumnCall{Call: call}
}

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

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

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

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

// TypeColumn mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) TypeColumn() *MockLoginSettingsRepositoryTypeColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).TypeColumn))
	return &MockLoginSettingsRepositoryTypeColumnCall{Call: call}
}

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

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

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

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

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

// TypeCondition indicates an expected call of TypeCondition.
func (mr *MockLoginSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockLoginSettingsRepositoryTypeConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).TypeCondition), typ)
	return &MockLoginSettingsRepositoryTypeConditionCall{Call: call}
}

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

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

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

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

// UniqueColumns mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) UniqueColumns() *MockLoginSettingsRepositoryUniqueColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockLoginSettingsRepository)(nil).UniqueColumns))
	return &MockLoginSettingsRepositoryUniqueColumnsCall{Call: call}
}

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

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

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

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

// UniqueCondition mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockLoginSettingsRepositoryUniqueConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
	return &MockLoginSettingsRepositoryUniqueConditionCall{Call: call}
}

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

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

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

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

// UpdatedAtColumn mocks base method.
func (m *MockLoginSettingsRepository) 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 *MockLoginSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockLoginSettingsRepositoryUpdatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).UpdatedAtColumn))
	return &MockLoginSettingsRepositoryUpdatedAtColumnCall{Call: call}
}

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

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

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

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