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

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

// Package domainmock is a generated GoMock package.
package domainmock

import (
	context "context"
	reflect "reflect"
	time "time"

	domain "github.com/zitadel/zitadel/backend/v3/domain"
	database "github.com/zitadel/zitadel/backend/v3/storage/database"
	json "github.com/zitadel/zitadel/backend/v3/storage/database/json"
	gomock "go.uber.org/mock/gomock"
)

// MockPasswordExpirySettingsRepository is a mock of PasswordExpirySettingsRepository interface.
type MockPasswordExpirySettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockPasswordExpirySettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockPasswordExpirySettingsRepositoryMockRecorder is the mock recorder for MockPasswordExpirySettingsRepository.
type MockPasswordExpirySettingsRepositoryMockRecorder struct {
	mock *MockPasswordExpirySettingsRepository
}

// NewMockPasswordExpirySettingsRepository creates a new mock instance.
func NewMockPasswordExpirySettingsRepository(ctrl *gomock.Controller) *MockPasswordExpirySettingsRepository {
	mock := &MockPasswordExpirySettingsRepository{ctrl: ctrl}
	mock.recorder = &MockPasswordExpirySettingsRepositoryMockRecorder{mock}
	return mock
}

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

// CreatedAtColumn mocks base method.
func (m *MockPasswordExpirySettingsRepository) CreatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// CreatedAtColumn indicates an expected call of CreatedAtColumn.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) CreatedAtColumn() *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).CreatedAtColumn))
	return &MockPasswordExpirySettingsRepositoryCreatedAtColumnCall{Call: call}
}

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

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

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

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

// Delete mocks base method.
func (m *MockPasswordExpirySettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, client, condition)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockPasswordExpirySettingsRepositoryDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).Delete), ctx, client, condition)
	return &MockPasswordExpirySettingsRepositoryDeleteCall{Call: call}
}

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

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

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

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

// Get mocks base method.
func (m *MockPasswordExpirySettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.PasswordExpirySettings, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*domain.PasswordExpirySettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// IDColumn mocks base method.
func (m *MockPasswordExpirySettingsRepository) IDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// IDColumn indicates an expected call of IDColumn.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) IDColumn() *MockPasswordExpirySettingsRepositoryIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).IDColumn))
	return &MockPasswordExpirySettingsRepositoryIDColumnCall{Call: call}
}

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

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

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

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

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

// IDCondition indicates an expected call of IDCondition.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) IDCondition(id any) *MockPasswordExpirySettingsRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).IDCondition), id)
	return &MockPasswordExpirySettingsRepositoryIDConditionCall{Call: call}
}

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

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

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

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

// InstanceIDColumn mocks base method.
func (m *MockPasswordExpirySettingsRepository) InstanceIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// InstanceIDColumn indicates an expected call of InstanceIDColumn.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) InstanceIDColumn() *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).InstanceIDColumn))
	return &MockPasswordExpirySettingsRepositoryInstanceIDColumnCall{Call: call}
}

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

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

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

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

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

// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).InstanceIDCondition), id)
	return &MockPasswordExpirySettingsRepositoryInstanceIDConditionCall{Call: call}
}

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

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

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

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

// List mocks base method.
func (m *MockPasswordExpirySettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.PasswordExpirySettings, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].([]*domain.PasswordExpirySettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// OrganizationIDColumn mocks base method.
func (m *MockPasswordExpirySettingsRepository) OrganizationIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OrganizationIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) OrganizationIDColumn() *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).OrganizationIDColumn))
	return &MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall{Call: call}
}

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

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

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

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

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

// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).OrganizationIDCondition), id)
	return &MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall{Call: call}
}

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

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

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

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

// PrimaryKeyColumns mocks base method.
func (m *MockPasswordExpirySettingsRepository) PrimaryKeyColumns() []database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyColumns")
	ret0, _ := ret[0].([]database.Column)
	return ret0
}

// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).PrimaryKeyColumns))
	return &MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall{Call: call}
}

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

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

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

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

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

// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
	return &MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall{Call: call}
}

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

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

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

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

// Set mocks base method.
func (m *MockPasswordExpirySettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.PasswordExpirySettings) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", ctx, client, settings)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockPasswordExpirySettingsRepositorySetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).Set), ctx, client, settings)
	return &MockPasswordExpirySettingsRepositorySetCall{Call: call}
}

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

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

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

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

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

// SetExpireWarnDays indicates an expected call of SetExpireWarnDays.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetExpireWarnDays(value any) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpireWarnDays", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetExpireWarnDays), value)
	return &MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall{Call: call}
}

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

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

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

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

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

// SetMaxAgeDays indicates an expected call of SetMaxAgeDays.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetMaxAgeDays(value any) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxAgeDays", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetMaxAgeDays), value)
	return &MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall{Call: call}
}

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

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

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

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

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

// SetSettingFields indicates an expected call of SetSettingFields.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetSettingFields(value any) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetSettingFields), value)
	return &MockPasswordExpirySettingsRepositorySetSettingFieldsCall{Call: call}
}

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

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

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

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

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

// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetUpdatedAt), updatedAt)
	return &MockPasswordExpirySettingsRepositorySetUpdatedAtCall{Call: call}
}

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

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

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

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

// SettingsColumn mocks base method.
func (m *MockPasswordExpirySettingsRepository) SettingsColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SettingsColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// SettingsColumn indicates an expected call of SettingsColumn.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SettingsColumn() *MockPasswordExpirySettingsRepositorySettingsColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SettingsColumn))
	return &MockPasswordExpirySettingsRepositorySettingsColumnCall{Call: call}
}

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

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

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

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

// StateColumn mocks base method.
func (m *MockPasswordExpirySettingsRepository) StateColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// StateColumn indicates an expected call of StateColumn.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) StateColumn() *MockPasswordExpirySettingsRepositoryStateColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).StateColumn))
	return &MockPasswordExpirySettingsRepositoryStateColumnCall{Call: call}
}

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

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

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

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

// TypeColumn mocks base method.
func (m *MockPasswordExpirySettingsRepository) TypeColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TypeColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// TypeColumn indicates an expected call of TypeColumn.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) TypeColumn() *MockPasswordExpirySettingsRepositoryTypeColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).TypeColumn))
	return &MockPasswordExpirySettingsRepositoryTypeColumnCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// UniqueColumns mocks base method.
func (m *MockPasswordExpirySettingsRepository) UniqueColumns() []database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UniqueColumns")
	ret0, _ := ret[0].([]database.Column)
	return ret0
}

// UniqueColumns indicates an expected call of UniqueColumns.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) UniqueColumns() *MockPasswordExpirySettingsRepositoryUniqueColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UniqueColumns))
	return &MockPasswordExpirySettingsRepositoryUniqueColumnsCall{Call: call}
}

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

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

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

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

// UniqueCondition mocks base method.
func (m *MockPasswordExpirySettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// UniqueCondition indicates an expected call of UniqueCondition.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockPasswordExpirySettingsRepositoryUniqueConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
	return &MockPasswordExpirySettingsRepositoryUniqueConditionCall{Call: call}
}

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

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

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

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

// UpdatedAtColumn mocks base method.
func (m *MockPasswordExpirySettingsRepository) UpdatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// UpdatedAtColumn indicates an expected call of UpdatedAtColumn.
func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) UpdatedAtColumn() *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UpdatedAtColumn))
	return &MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall{Call: call}
}

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

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

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

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