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

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

// 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"
)

// MockInstanceDomainRepository is a mock of InstanceDomainRepository interface.
type MockInstanceDomainRepository struct {
	ctrl     *gomock.Controller
	recorder *MockInstanceDomainRepositoryMockRecorder
	isgomock struct{}
}

// MockInstanceDomainRepositoryMockRecorder is the mock recorder for MockInstanceDomainRepository.
type MockInstanceDomainRepositoryMockRecorder struct {
	mock *MockInstanceDomainRepository
}

// NewMockInstanceDomainRepository creates a new mock instance.
func NewMockInstanceDomainRepository(ctrl *gomock.Controller) *MockInstanceDomainRepository {
	mock := &MockInstanceDomainRepository{ctrl: ctrl}
	mock.recorder = &MockInstanceDomainRepositoryMockRecorder{mock}
	return mock
}

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

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

// Add indicates an expected call of Add.
func (mr *MockInstanceDomainRepositoryMockRecorder) Add(ctx, client, arg2 any) *MockInstanceDomainRepositoryAddCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockInstanceDomainRepository)(nil).Add), ctx, client, arg2)
	return &MockInstanceDomainRepositoryAddCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// DomainColumn indicates an expected call of DomainColumn.
func (mr *MockInstanceDomainRepositoryMockRecorder) DomainColumn() *MockInstanceDomainRepositoryDomainColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainColumn", reflect.TypeOf((*MockInstanceDomainRepository)(nil).DomainColumn))
	return &MockInstanceDomainRepositoryDomainColumnCall{Call: call}
}

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

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

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

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

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

// DomainCondition indicates an expected call of DomainCondition.
func (mr *MockInstanceDomainRepositoryMockRecorder) DomainCondition(op, arg1 any) *MockInstanceDomainRepositoryDomainConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DomainCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).DomainCondition), op, arg1)
	return &MockInstanceDomainRepositoryDomainConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockInstanceDomainRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockInstanceDomainRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).InstanceIDCondition), instanceID)
	return &MockInstanceDomainRepositoryInstanceIDConditionCall{Call: call}
}

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

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

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

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

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

// IsGeneratedColumn indicates an expected call of IsGeneratedColumn.
func (mr *MockInstanceDomainRepositoryMockRecorder) IsGeneratedColumn() *MockInstanceDomainRepositoryIsGeneratedColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsGeneratedColumn", reflect.TypeOf((*MockInstanceDomainRepository)(nil).IsGeneratedColumn))
	return &MockInstanceDomainRepositoryIsGeneratedColumnCall{Call: call}
}

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

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

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

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

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

// IsGeneratedCondition indicates an expected call of IsGeneratedCondition.
func (mr *MockInstanceDomainRepositoryMockRecorder) IsGeneratedCondition(isGenerated any) *MockInstanceDomainRepositoryIsGeneratedConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsGeneratedCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).IsGeneratedCondition), isGenerated)
	return &MockInstanceDomainRepositoryIsGeneratedConditionCall{Call: call}
}

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

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

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

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

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

// IsPrimaryColumn indicates an expected call of IsPrimaryColumn.
func (mr *MockInstanceDomainRepositoryMockRecorder) IsPrimaryColumn() *MockInstanceDomainRepositoryIsPrimaryColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPrimaryColumn", reflect.TypeOf((*MockInstanceDomainRepository)(nil).IsPrimaryColumn))
	return &MockInstanceDomainRepositoryIsPrimaryColumnCall{Call: call}
}

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

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

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

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

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

// IsPrimaryCondition indicates an expected call of IsPrimaryCondition.
func (mr *MockInstanceDomainRepositoryMockRecorder) IsPrimaryCondition(isPrimary any) *MockInstanceDomainRepositoryIsPrimaryConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPrimaryCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).IsPrimaryCondition), isPrimary)
	return &MockInstanceDomainRepositoryIsPrimaryConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
func (mr *MockInstanceDomainRepositoryMockRecorder) PrimaryKeyCondition(arg0 any) *MockInstanceDomainRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).PrimaryKeyCondition), arg0)
	return &MockInstanceDomainRepositoryPrimaryKeyConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// SetPrimary indicates an expected call of SetPrimary.
func (mr *MockInstanceDomainRepositoryMockRecorder) SetPrimary() *MockInstanceDomainRepositorySetPrimaryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPrimary", reflect.TypeOf((*MockInstanceDomainRepository)(nil).SetPrimary))
	return &MockInstanceDomainRepositorySetPrimaryCall{Call: call}
}

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

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

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

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

// SetType mocks base method.
func (m *MockInstanceDomainRepository) SetType(typ domain.DomainType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetType", typ)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetType indicates an expected call of SetType.
func (mr *MockInstanceDomainRepositoryMockRecorder) SetType(typ any) *MockInstanceDomainRepositorySetTypeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetType", reflect.TypeOf((*MockInstanceDomainRepository)(nil).SetType), typ)
	return &MockInstanceDomainRepositorySetTypeCall{Call: call}
}

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

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

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

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

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

// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockInstanceDomainRepositoryMockRecorder) SetUpdatedAt(t any) *MockInstanceDomainRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockInstanceDomainRepository)(nil).SetUpdatedAt), t)
	return &MockInstanceDomainRepositorySetUpdatedAtCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Update mocks base method.
func (m *MockInstanceDomainRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client, condition}
	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 *MockInstanceDomainRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockInstanceDomainRepositoryUpdateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, condition}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInstanceDomainRepository)(nil).Update), varargs...)
	return &MockInstanceDomainRepositoryUpdateCall{Call: call}
}

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

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

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

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

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

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

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

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

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