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

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

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

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

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

// MockDomainSettingsRepository is a mock of DomainSettingsRepository interface.
type MockDomainSettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockDomainSettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockDomainSettingsRepositoryMockRecorder is the mock recorder for MockDomainSettingsRepository.
type MockDomainSettingsRepositoryMockRecorder struct {
	mock *MockDomainSettingsRepository
}

// NewMockDomainSettingsRepository creates a new mock instance.
func NewMockDomainSettingsRepository(ctrl *gomock.Controller) *MockDomainSettingsRepository {
	mock := &MockDomainSettingsRepository{ctrl: ctrl}
	mock.recorder = &MockDomainSettingsRepositoryMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetLoginNameIncludesDomain indicates an expected call of SetLoginNameIncludesDomain.
func (mr *MockDomainSettingsRepositoryMockRecorder) SetLoginNameIncludesDomain(value any) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoginNameIncludesDomain", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetLoginNameIncludesDomain), value)
	return &MockDomainSettingsRepositorySetLoginNameIncludesDomainCall{Call: call}
}

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

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

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

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

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

// SetRequireOrgDomainVerification indicates an expected call of SetRequireOrgDomainVerification.
func (mr *MockDomainSettingsRepositoryMockRecorder) SetRequireOrgDomainVerification(value any) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRequireOrgDomainVerification", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetRequireOrgDomainVerification), value)
	return &MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall{Call: call}
}

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

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

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

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

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

// SetSMTPSenderAddressMatchesInstanceDomain indicates an expected call of SetSMTPSenderAddressMatchesInstanceDomain.
func (mr *MockDomainSettingsRepositoryMockRecorder) SetSMTPSenderAddressMatchesInstanceDomain(value any) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSMTPSenderAddressMatchesInstanceDomain", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetSMTPSenderAddressMatchesInstanceDomain), value)
	return &MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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