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

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

// TypeCondition mocks base method.
func (m *MockLockoutSettingsRepository) 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 *MockLockoutSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockLockoutSettingsRepositoryTypeConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).TypeCondition), typ)
	return &MockLockoutSettingsRepositoryTypeConditionCall{Call: call}
}

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

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

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

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