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

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

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

// MockProjectRepository is a mock of ProjectRepository interface.
type MockProjectRepository struct {
	ctrl     *gomock.Controller
	recorder *MockProjectRepositoryMockRecorder
	isgomock struct{}
}

// MockProjectRepositoryMockRecorder is the mock recorder for MockProjectRepository.
type MockProjectRepositoryMockRecorder struct {
	mock *MockProjectRepository
}

// NewMockProjectRepository creates a new mock instance.
func NewMockProjectRepository(ctrl *gomock.Controller) *MockProjectRepository {
	mock := &MockProjectRepository{ctrl: ctrl}
	mock.recorder = &MockProjectRepositoryMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

// Delete mocks base method.
func (m *MockProjectRepository) 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 *MockProjectRepositoryMockRecorder) Delete(ctx, client, condition any) *MockProjectRepositoryDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockProjectRepository)(nil).Delete), ctx, client, condition)
	return &MockProjectRepositoryDeleteCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// IDCondition indicates an expected call of IDCondition.
func (mr *MockProjectRepositoryMockRecorder) IDCondition(projectID any) *MockProjectRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockProjectRepository)(nil).IDCondition), projectID)
	return &MockProjectRepositoryIDConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// InstanceIDCondition mocks base method.
func (m *MockProjectRepository) 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 *MockProjectRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockProjectRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockProjectRepository)(nil).InstanceIDCondition), instanceID)
	return &MockProjectRepositoryInstanceIDConditionCall{Call: call}
}

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

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

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

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

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

// IsAuthorizationRequiredColumn indicates an expected call of IsAuthorizationRequiredColumn.
func (mr *MockProjectRepositoryMockRecorder) IsAuthorizationRequiredColumn() *MockProjectRepositoryIsAuthorizationRequiredColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAuthorizationRequiredColumn", reflect.TypeOf((*MockProjectRepository)(nil).IsAuthorizationRequiredColumn))
	return &MockProjectRepositoryIsAuthorizationRequiredColumnCall{Call: call}
}

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

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

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

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

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

// IsProjectAccessRequiredColumn indicates an expected call of IsProjectAccessRequiredColumn.
func (mr *MockProjectRepositoryMockRecorder) IsProjectAccessRequiredColumn() *MockProjectRepositoryIsProjectAccessRequiredColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsProjectAccessRequiredColumn", reflect.TypeOf((*MockProjectRepository)(nil).IsProjectAccessRequiredColumn))
	return &MockProjectRepositoryIsProjectAccessRequiredColumnCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// NameCondition mocks base method.
func (m *MockProjectRepository) 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 *MockProjectRepositoryMockRecorder) NameCondition(op, name any) *MockProjectRepositoryNameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NameCondition", reflect.TypeOf((*MockProjectRepository)(nil).NameCondition), op, name)
	return &MockProjectRepositoryNameConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
func (mr *MockProjectRepositoryMockRecorder) OrganizationIDCondition(organizationID any) *MockProjectRepositoryOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockProjectRepository)(nil).OrganizationIDCondition), organizationID)
	return &MockProjectRepositoryOrganizationIDConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Role indicates an expected call of Role.
func (mr *MockProjectRepositoryMockRecorder) Role() *MockProjectRepositoryRoleCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Role", reflect.TypeOf((*MockProjectRepository)(nil).Role))
	return &MockProjectRepositoryRoleCall{Call: call}
}

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

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

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

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

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

// SetIsAuthorizationRequired indicates an expected call of SetIsAuthorizationRequired.
func (mr *MockProjectRepositoryMockRecorder) SetIsAuthorizationRequired(isAuthorizationRequired any) *MockProjectRepositorySetIsAuthorizationRequiredCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsAuthorizationRequired", reflect.TypeOf((*MockProjectRepository)(nil).SetIsAuthorizationRequired), isAuthorizationRequired)
	return &MockProjectRepositorySetIsAuthorizationRequiredCall{Call: call}
}

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

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

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

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

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

// SetIsProjectAccessRequired indicates an expected call of SetIsProjectAccessRequired.
func (mr *MockProjectRepositoryMockRecorder) SetIsProjectAccessRequired(isProjectAccessRequired any) *MockProjectRepositorySetIsProjectAccessRequiredCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsProjectAccessRequired", reflect.TypeOf((*MockProjectRepository)(nil).SetIsProjectAccessRequired), isProjectAccessRequired)
	return &MockProjectRepositorySetIsProjectAccessRequiredCall{Call: call}
}

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

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

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

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

// SetName mocks base method.
func (m *MockProjectRepository) 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 *MockProjectRepositoryMockRecorder) SetName(name any) *MockProjectRepositorySetNameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetName", reflect.TypeOf((*MockProjectRepository)(nil).SetName), name)
	return &MockProjectRepositorySetNameCall{Call: call}
}

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

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

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

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

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

// SetShouldAssertRole indicates an expected call of SetShouldAssertRole.
func (mr *MockProjectRepositoryMockRecorder) SetShouldAssertRole(shouldAssertRole any) *MockProjectRepositorySetShouldAssertRoleCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShouldAssertRole", reflect.TypeOf((*MockProjectRepository)(nil).SetShouldAssertRole), shouldAssertRole)
	return &MockProjectRepositorySetShouldAssertRoleCall{Call: call}
}

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

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

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

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

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

// SetState indicates an expected call of SetState.
func (mr *MockProjectRepositoryMockRecorder) SetState(state any) *MockProjectRepositorySetStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockProjectRepository)(nil).SetState), state)
	return &MockProjectRepositorySetStateCall{Call: call}
}

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

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

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

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

// SetUpdatedAt mocks base method.
func (m *MockProjectRepository) 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 *MockProjectRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockProjectRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockProjectRepository)(nil).SetUpdatedAt), updatedAt)
	return &MockProjectRepositorySetUpdatedAtCall{Call: call}
}

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

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

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

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

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

// SetUsedLabelingSettingOwner indicates an expected call of SetUsedLabelingSettingOwner.
func (mr *MockProjectRepositoryMockRecorder) SetUsedLabelingSettingOwner(usedLabelingSettingOwner any) *MockProjectRepositorySetUsedLabelingSettingOwnerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUsedLabelingSettingOwner", reflect.TypeOf((*MockProjectRepository)(nil).SetUsedLabelingSettingOwner), usedLabelingSettingOwner)
	return &MockProjectRepositorySetUsedLabelingSettingOwnerCall{Call: call}
}

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

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

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

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

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

// ShouldAssertRoleColumn indicates an expected call of ShouldAssertRoleColumn.
func (mr *MockProjectRepositoryMockRecorder) ShouldAssertRoleColumn() *MockProjectRepositoryShouldAssertRoleColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldAssertRoleColumn", reflect.TypeOf((*MockProjectRepository)(nil).ShouldAssertRoleColumn))
	return &MockProjectRepositoryShouldAssertRoleColumnCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// StateCondition mocks base method.
func (m *MockProjectRepository) StateCondition(state domain.ProjectState) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateCondition", state)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// StateCondition indicates an expected call of StateCondition.
func (mr *MockProjectRepositoryMockRecorder) StateCondition(state any) *MockProjectRepositoryStateConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockProjectRepository)(nil).StateCondition), state)
	return &MockProjectRepositoryStateConditionCall{Call: call}
}

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

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

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

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

// Update mocks base method.
func (m *MockProjectRepository) 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 *MockProjectRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockProjectRepositoryUpdateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, condition}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockProjectRepository)(nil).Update), varargs...)
	return &MockProjectRepositoryUpdateCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// UsedLabelingSettingOwnerColumn indicates an expected call of UsedLabelingSettingOwnerColumn.
func (mr *MockProjectRepositoryMockRecorder) UsedLabelingSettingOwnerColumn() *MockProjectRepositoryUsedLabelingSettingOwnerColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsedLabelingSettingOwnerColumn", reflect.TypeOf((*MockProjectRepository)(nil).UsedLabelingSettingOwnerColumn))
	return &MockProjectRepositoryUsedLabelingSettingOwnerColumnCall{Call: call}
}

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

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

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

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