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

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

// MockProjectGrantRepository is a mock of ProjectGrantRepository interface.
type MockProjectGrantRepository struct {
	ctrl     *gomock.Controller
	recorder *MockProjectGrantRepositoryMockRecorder
	isgomock struct{}
}

// MockProjectGrantRepositoryMockRecorder is the mock recorder for MockProjectGrantRepository.
type MockProjectGrantRepositoryMockRecorder struct {
	mock *MockProjectGrantRepository
}

// NewMockProjectGrantRepository creates a new mock instance.
func NewMockProjectGrantRepository(ctrl *gomock.Controller) *MockProjectGrantRepository {
	mock := &MockProjectGrantRepository{ctrl: ctrl}
	mock.recorder = &MockProjectGrantRepositoryMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m *MockProjectGrantRepository) Create(ctx context.Context, client database.QueryExecutor, project *domain.ProjectGrant) 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 *MockProjectGrantRepositoryMockRecorder) Create(ctx, client, project any) *MockProjectGrantRepositoryCreateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockProjectGrantRepository)(nil).Create), ctx, client, project)
	return &MockProjectGrantRepositoryCreateCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ExistsRoleKey indicates an expected call of ExistsRoleKey.
func (mr *MockProjectGrantRepositoryMockRecorder) ExistsRoleKey(cond any) *MockProjectGrantRepositoryExistsRoleKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsRoleKey", reflect.TypeOf((*MockProjectGrantRepository)(nil).ExistsRoleKey), cond)
	return &MockProjectGrantRepositoryExistsRoleKeyCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// GrantedOrganizationIDColumn indicates an expected call of GrantedOrganizationIDColumn.
func (mr *MockProjectGrantRepositoryMockRecorder) GrantedOrganizationIDColumn() *MockProjectGrantRepositoryGrantedOrganizationIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantedOrganizationIDColumn", reflect.TypeOf((*MockProjectGrantRepository)(nil).GrantedOrganizationIDColumn))
	return &MockProjectGrantRepositoryGrantedOrganizationIDColumnCall{Call: call}
}

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

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

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

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

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

// GrantedOrganizationIDCondition indicates an expected call of GrantedOrganizationIDCondition.
func (mr *MockProjectGrantRepositoryMockRecorder) GrantedOrganizationIDCondition(grantedOrgID any) *MockProjectGrantRepositoryGrantedOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantedOrganizationIDCondition", reflect.TypeOf((*MockProjectGrantRepository)(nil).GrantedOrganizationIDCondition), grantedOrgID)
	return &MockProjectGrantRepositoryGrantedOrganizationIDConditionCall{Call: call}
}

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

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

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

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

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

// GrantingOrganizationIDColumn indicates an expected call of GrantingOrganizationIDColumn.
func (mr *MockProjectGrantRepositoryMockRecorder) GrantingOrganizationIDColumn() *MockProjectGrantRepositoryGrantingOrganizationIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantingOrganizationIDColumn", reflect.TypeOf((*MockProjectGrantRepository)(nil).GrantingOrganizationIDColumn))
	return &MockProjectGrantRepositoryGrantingOrganizationIDColumnCall{Call: call}
}

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

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

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

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

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

// GrantingOrganizationIDCondition indicates an expected call of GrantingOrganizationIDCondition.
func (mr *MockProjectGrantRepositoryMockRecorder) GrantingOrganizationIDCondition(grantingOrgID any) *MockProjectGrantRepositoryGrantingOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantingOrganizationIDCondition", reflect.TypeOf((*MockProjectGrantRepository)(nil).GrantingOrganizationIDCondition), grantingOrgID)
	return &MockProjectGrantRepositoryGrantingOrganizationIDConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ProjectIDColumn indicates an expected call of ProjectIDColumn.
func (mr *MockProjectGrantRepositoryMockRecorder) ProjectIDColumn() *MockProjectGrantRepositoryProjectIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectIDColumn", reflect.TypeOf((*MockProjectGrantRepository)(nil).ProjectIDColumn))
	return &MockProjectGrantRepositoryProjectIDColumnCall{Call: call}
}

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

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

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

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

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

// ProjectIDCondition indicates an expected call of ProjectIDCondition.
func (mr *MockProjectGrantRepositoryMockRecorder) ProjectIDCondition(projectID any) *MockProjectGrantRepositoryProjectIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectIDCondition", reflect.TypeOf((*MockProjectGrantRepository)(nil).ProjectIDCondition), projectID)
	return &MockProjectGrantRepositoryProjectIDConditionCall{Call: call}
}

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

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

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

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

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

// RoleKeyCondition indicates an expected call of RoleKeyCondition.
func (mr *MockProjectGrantRepositoryMockRecorder) RoleKeyCondition(op, role any) *MockProjectGrantRepositoryRoleKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleKeyCondition", reflect.TypeOf((*MockProjectGrantRepository)(nil).RoleKeyCondition), op, role)
	return &MockProjectGrantRepositoryRoleKeyConditionCall{Call: call}
}

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

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

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

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

// SetState mocks base method.
func (m *MockProjectGrantRepository) SetState(state domain.ProjectGrantState) 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 *MockProjectGrantRepositoryMockRecorder) SetState(state any) *MockProjectGrantRepositorySetStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockProjectGrantRepository)(nil).SetState), state)
	return &MockProjectGrantRepositorySetStateCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// StateCondition mocks base method.
func (m *MockProjectGrantRepository) StateCondition(state domain.ProjectGrantState) 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 *MockProjectGrantRepositoryMockRecorder) StateCondition(state any) *MockProjectGrantRepositoryStateConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockProjectGrantRepository)(nil).StateCondition), state)
	return &MockProjectGrantRepositoryStateConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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