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

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

// 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"
	gomock "go.uber.org/mock/gomock"
	language "golang.org/x/text/language"
)

// MockInstanceRepository is a mock of InstanceRepository interface.
type MockInstanceRepository struct {
	ctrl     *gomock.Controller
	recorder *MockInstanceRepositoryMockRecorder
	isgomock struct{}
}

// MockInstanceRepositoryMockRecorder is the mock recorder for MockInstanceRepository.
type MockInstanceRepositoryMockRecorder struct {
	mock *MockInstanceRepository
}

// NewMockInstanceRepository creates a new mock instance.
func NewMockInstanceRepository(ctrl *gomock.Controller) *MockInstanceRepository {
	mock := &MockInstanceRepository{ctrl: ctrl}
	mock.recorder = &MockInstanceRepositoryMockRecorder{mock}
	return mock
}

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

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

// ConsoleAppIDColumn indicates an expected call of ConsoleAppIDColumn.
func (mr *MockInstanceRepositoryMockRecorder) ConsoleAppIDColumn() *MockInstanceRepositoryConsoleAppIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsoleAppIDColumn", reflect.TypeOf((*MockInstanceRepository)(nil).ConsoleAppIDColumn))
	return &MockInstanceRepositoryConsoleAppIDColumnCall{Call: call}
}

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

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

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

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

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

// ConsoleClientIDColumn indicates an expected call of ConsoleClientIDColumn.
func (mr *MockInstanceRepositoryMockRecorder) ConsoleClientIDColumn() *MockInstanceRepositoryConsoleClientIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsoleClientIDColumn", reflect.TypeOf((*MockInstanceRepository)(nil).ConsoleClientIDColumn))
	return &MockInstanceRepositoryConsoleClientIDColumnCall{Call: call}
}

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

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

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

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

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

// Create indicates an expected call of Create.
func (mr *MockInstanceRepositoryMockRecorder) Create(ctx, client, instance any) *MockInstanceRepositoryCreateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockInstanceRepository)(nil).Create), ctx, client, instance)
	return &MockInstanceRepositoryCreateCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// DefaultLanguageColumn indicates an expected call of DefaultLanguageColumn.
func (mr *MockInstanceRepositoryMockRecorder) DefaultLanguageColumn() *MockInstanceRepositoryDefaultLanguageColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultLanguageColumn", reflect.TypeOf((*MockInstanceRepository)(nil).DefaultLanguageColumn))
	return &MockInstanceRepositoryDefaultLanguageColumnCall{Call: call}
}

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

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

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

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

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

// DefaultOrgIDColumn indicates an expected call of DefaultOrgIDColumn.
func (mr *MockInstanceRepositoryMockRecorder) DefaultOrgIDColumn() *MockInstanceRepositoryDefaultOrgIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultOrgIDColumn", reflect.TypeOf((*MockInstanceRepository)(nil).DefaultOrgIDColumn))
	return &MockInstanceRepositoryDefaultOrgIDColumnCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// ExistsDomain indicates an expected call of ExistsDomain.
func (mr *MockInstanceRepositoryMockRecorder) ExistsDomain(cond any) *MockInstanceRepositoryExistsDomainCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsDomain", reflect.TypeOf((*MockInstanceRepository)(nil).ExistsDomain), cond)
	return &MockInstanceRepositoryExistsDomainCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// IAMProjectIDColumn indicates an expected call of IAMProjectIDColumn.
func (mr *MockInstanceRepositoryMockRecorder) IAMProjectIDColumn() *MockInstanceRepositoryIAMProjectIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IAMProjectIDColumn", reflect.TypeOf((*MockInstanceRepository)(nil).IAMProjectIDColumn))
	return &MockInstanceRepositoryIAMProjectIDColumnCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// IDCondition indicates an expected call of IDCondition.
func (mr *MockInstanceRepositoryMockRecorder) IDCondition(instanceID any) *MockInstanceRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockInstanceRepository)(nil).IDCondition), instanceID)
	return &MockInstanceRepositoryIDConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// LoadDomains mocks base method.
func (m *MockInstanceRepository) LoadDomains() domain.InstanceRepository {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadDomains")
	ret0, _ := ret[0].(domain.InstanceRepository)
	return ret0
}

// LoadDomains indicates an expected call of LoadDomains.
func (mr *MockInstanceRepositoryMockRecorder) LoadDomains() *MockInstanceRepositoryLoadDomainsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadDomains", reflect.TypeOf((*MockInstanceRepository)(nil).LoadDomains))
	return &MockInstanceRepositoryLoadDomainsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockInstanceRepositoryLoadDomainsCall) Return(arg0 domain.InstanceRepository) *MockInstanceRepositoryLoadDomainsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockInstanceRepositoryLoadDomainsCall) Do(f func() domain.InstanceRepository) *MockInstanceRepositoryLoadDomainsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInstanceRepositoryLoadDomainsCall) DoAndReturn(f func() domain.InstanceRepository) *MockInstanceRepositoryLoadDomainsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// NameColumn indicates an expected call of NameColumn.
func (mr *MockInstanceRepositoryMockRecorder) NameColumn() *MockInstanceRepositoryNameColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NameColumn", reflect.TypeOf((*MockInstanceRepository)(nil).NameColumn))
	return &MockInstanceRepositoryNameColumnCall{Call: call}
}

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

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

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

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

// NameCondition mocks base method.
func (m *MockInstanceRepository) NameCondition(op database.TextOperation, name string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NameCondition", op, name)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// NameCondition indicates an expected call of NameCondition.
func (mr *MockInstanceRepositoryMockRecorder) NameCondition(op, name any) *MockInstanceRepositoryNameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NameCondition", reflect.TypeOf((*MockInstanceRepository)(nil).NameCondition), op, name)
	return &MockInstanceRepositoryNameConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetConsoleAppID indicates an expected call of SetConsoleAppID.
func (mr *MockInstanceRepositoryMockRecorder) SetConsoleAppID(id any) *MockInstanceRepositorySetConsoleAppIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConsoleAppID", reflect.TypeOf((*MockInstanceRepository)(nil).SetConsoleAppID), id)
	return &MockInstanceRepositorySetConsoleAppIDCall{Call: call}
}

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

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

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

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

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

// SetConsoleClientID indicates an expected call of SetConsoleClientID.
func (mr *MockInstanceRepositoryMockRecorder) SetConsoleClientID(id any) *MockInstanceRepositorySetConsoleClientIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConsoleClientID", reflect.TypeOf((*MockInstanceRepository)(nil).SetConsoleClientID), id)
	return &MockInstanceRepositorySetConsoleClientIDCall{Call: call}
}

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

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

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

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

// SetDefaultLanguage mocks base method.
func (m *MockInstanceRepository) SetDefaultLanguage(arg0 language.Tag) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDefaultLanguage", arg0)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetDefaultLanguage indicates an expected call of SetDefaultLanguage.
func (mr *MockInstanceRepositoryMockRecorder) SetDefaultLanguage(arg0 any) *MockInstanceRepositorySetDefaultLanguageCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultLanguage", reflect.TypeOf((*MockInstanceRepository)(nil).SetDefaultLanguage), arg0)
	return &MockInstanceRepositorySetDefaultLanguageCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockInstanceRepositorySetDefaultLanguageCall) Do(f func(language.Tag) database.Change) *MockInstanceRepositorySetDefaultLanguageCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockInstanceRepositorySetDefaultLanguageCall) DoAndReturn(f func(language.Tag) database.Change) *MockInstanceRepositorySetDefaultLanguageCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetDefaultOrg indicates an expected call of SetDefaultOrg.
func (mr *MockInstanceRepositoryMockRecorder) SetDefaultOrg(id any) *MockInstanceRepositorySetDefaultOrgCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultOrg", reflect.TypeOf((*MockInstanceRepository)(nil).SetDefaultOrg), id)
	return &MockInstanceRepositorySetDefaultOrgCall{Call: call}
}

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

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

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

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

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

// SetIAMProject indicates an expected call of SetIAMProject.
func (mr *MockInstanceRepositoryMockRecorder) SetIAMProject(id any) *MockInstanceRepositorySetIAMProjectCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIAMProject", reflect.TypeOf((*MockInstanceRepository)(nil).SetIAMProject), id)
	return &MockInstanceRepositorySetIAMProjectCall{Call: call}
}

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

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

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

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

// SetName mocks base method.
func (m *MockInstanceRepository) SetName(name string) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetName", name)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetName indicates an expected call of SetName.
func (mr *MockInstanceRepositoryMockRecorder) SetName(name any) *MockInstanceRepositorySetNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetName", reflect.TypeOf((*MockInstanceRepository)(nil).SetName), name)
	return &MockInstanceRepositorySetNameCall{Call: call}
}

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

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

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

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

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

// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockInstanceRepositoryMockRecorder) SetUpdatedAt(arg0 any) *MockInstanceRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockInstanceRepository)(nil).SetUpdatedAt), arg0)
	return &MockInstanceRepositorySetUpdatedAtCall{Call: call}
}

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

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

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

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

// Update mocks base method.
func (m *MockInstanceRepository) Update(ctx context.Context, client database.QueryExecutor, id string, changes ...database.Change) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client, id}
	for _, a := range changes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockInstanceRepositoryMockRecorder) Update(ctx, client, id any, changes ...any) *MockInstanceRepositoryUpdateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, id}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInstanceRepository)(nil).Update), varargs...)
	return &MockInstanceRepositoryUpdateCall{Call: call}
}

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

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

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

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

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

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

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

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

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