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