// Code generated by mockery v2.48.0. DO NOT EDIT.

package component

import (
	context "context"

	deploy "opencsg.com/csghub-server/builder/deploy"
	database "opencsg.com/csghub-server/builder/store/database"

	gitserver "opencsg.com/csghub-server/builder/git/gitserver"

	io "io"

	membership "opencsg.com/csghub-server/builder/git/membership"

	mock "github.com/stretchr/testify/mock"

	types "opencsg.com/csghub-server/common/types"
)

// MockRepoComponent is an autogenerated mock type for the RepoComponent type
type MockRepoComponent struct {
	mock.Mock
}

type MockRepoComponent_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRepoComponent) EXPECT() *MockRepoComponent_Expecter {
	return &MockRepoComponent_Expecter{mock: &_m.Mock}
}

// AllFiles provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) AllFiles(ctx context.Context, req types.GetAllFilesReq) ([]*types.File, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for AllFiles")
	}

	var r0 []*types.File
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.GetAllFilesReq) ([]*types.File, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.GetAllFilesReq) []*types.File); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.File)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.GetAllFilesReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllFiles'
type MockRepoComponent_AllFiles_Call struct {
	*mock.Call
}

// AllFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.GetAllFilesReq
func (_e *MockRepoComponent_Expecter) AllFiles(ctx interface{}, req interface{}) *MockRepoComponent_AllFiles_Call {
	return &MockRepoComponent_AllFiles_Call{Call: _e.mock.On("AllFiles", ctx, req)}
}

func (_c *MockRepoComponent_AllFiles_Call) Run(run func(ctx context.Context, req types.GetAllFilesReq)) *MockRepoComponent_AllFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.GetAllFilesReq))
	})
	return _c
}

func (_c *MockRepoComponent_AllFiles_Call) Return(_a0 []*types.File, _a1 error) *MockRepoComponent_AllFiles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllFiles_Call) RunAndReturn(run func(context.Context, types.GetAllFilesReq) ([]*types.File, error)) *MockRepoComponent_AllFiles_Call {
	_c.Call.Return(run)
	return _c
}

// AllowAccessByRepoID provides a mock function with given fields: ctx, repoID, username
func (_m *MockRepoComponent) AllowAccessByRepoID(ctx context.Context, repoID int64, username string) (bool, error) {
	ret := _m.Called(ctx, repoID, username)

	if len(ret) == 0 {
		panic("no return value specified for AllowAccessByRepoID")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, string) (bool, error)); ok {
		return rf(ctx, repoID, username)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64, string) bool); ok {
		r0 = rf(ctx, repoID, username)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok {
		r1 = rf(ctx, repoID, username)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllowAccessByRepoID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowAccessByRepoID'
type MockRepoComponent_AllowAccessByRepoID_Call struct {
	*mock.Call
}

// AllowAccessByRepoID is a helper method to define mock.On call
//   - ctx context.Context
//   - repoID int64
//   - username string
func (_e *MockRepoComponent_Expecter) AllowAccessByRepoID(ctx interface{}, repoID interface{}, username interface{}) *MockRepoComponent_AllowAccessByRepoID_Call {
	return &MockRepoComponent_AllowAccessByRepoID_Call{Call: _e.mock.On("AllowAccessByRepoID", ctx, repoID, username)}
}

func (_c *MockRepoComponent_AllowAccessByRepoID_Call) Run(run func(ctx context.Context, repoID int64, username string)) *MockRepoComponent_AllowAccessByRepoID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(string))
	})
	return _c
}

func (_c *MockRepoComponent_AllowAccessByRepoID_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_AllowAccessByRepoID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllowAccessByRepoID_Call) RunAndReturn(run func(context.Context, int64, string) (bool, error)) *MockRepoComponent_AllowAccessByRepoID_Call {
	_c.Call.Return(run)
	return _c
}

// AllowAccessDeploy provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) AllowAccessDeploy(ctx context.Context, req types.DeployActReq) (bool, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for AllowAccessDeploy")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) (bool, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) bool); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.DeployActReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllowAccessDeploy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowAccessDeploy'
type MockRepoComponent_AllowAccessDeploy_Call struct {
	*mock.Call
}

// AllowAccessDeploy is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.DeployActReq
func (_e *MockRepoComponent_Expecter) AllowAccessDeploy(ctx interface{}, req interface{}) *MockRepoComponent_AllowAccessDeploy_Call {
	return &MockRepoComponent_AllowAccessDeploy_Call{Call: _e.mock.On("AllowAccessDeploy", ctx, req)}
}

func (_c *MockRepoComponent_AllowAccessDeploy_Call) Run(run func(ctx context.Context, req types.DeployActReq)) *MockRepoComponent_AllowAccessDeploy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeployActReq))
	})
	return _c
}

func (_c *MockRepoComponent_AllowAccessDeploy_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_AllowAccessDeploy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllowAccessDeploy_Call) RunAndReturn(run func(context.Context, types.DeployActReq) (bool, error)) *MockRepoComponent_AllowAccessDeploy_Call {
	_c.Call.Return(run)
	return _c
}

// AllowAccessEndpoint provides a mock function with given fields: ctx, currentUser, _a2
func (_m *MockRepoComponent) AllowAccessEndpoint(ctx context.Context, currentUser string, _a2 *database.Deploy) (bool, error) {
	ret := _m.Called(ctx, currentUser, _a2)

	if len(ret) == 0 {
		panic("no return value specified for AllowAccessEndpoint")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *database.Deploy) (bool, error)); ok {
		return rf(ctx, currentUser, _a2)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *database.Deploy) bool); ok {
		r0 = rf(ctx, currentUser, _a2)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *database.Deploy) error); ok {
		r1 = rf(ctx, currentUser, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllowAccessEndpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowAccessEndpoint'
type MockRepoComponent_AllowAccessEndpoint_Call struct {
	*mock.Call
}

// AllowAccessEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - currentUser string
//   - _a2 *database.Deploy
func (_e *MockRepoComponent_Expecter) AllowAccessEndpoint(ctx interface{}, currentUser interface{}, _a2 interface{}) *MockRepoComponent_AllowAccessEndpoint_Call {
	return &MockRepoComponent_AllowAccessEndpoint_Call{Call: _e.mock.On("AllowAccessEndpoint", ctx, currentUser, _a2)}
}

func (_c *MockRepoComponent_AllowAccessEndpoint_Call) Run(run func(ctx context.Context, currentUser string, _a2 *database.Deploy)) *MockRepoComponent_AllowAccessEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*database.Deploy))
	})
	return _c
}

func (_c *MockRepoComponent_AllowAccessEndpoint_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_AllowAccessEndpoint_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllowAccessEndpoint_Call) RunAndReturn(run func(context.Context, string, *database.Deploy) (bool, error)) *MockRepoComponent_AllowAccessEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// AllowAdminAccess provides a mock function with given fields: ctx, repoType, namespace, name, username
func (_m *MockRepoComponent) AllowAdminAccess(ctx context.Context, repoType types.RepositoryType, namespace string, name string, username string) (bool, error) {
	ret := _m.Called(ctx, repoType, namespace, name, username)

	if len(ret) == 0 {
		panic("no return value specified for AllowAdminAccess")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) (bool, error)); ok {
		return rf(ctx, repoType, namespace, name, username)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) bool); ok {
		r0 = rf(ctx, repoType, namespace, name, username)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, string, string) error); ok {
		r1 = rf(ctx, repoType, namespace, name, username)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllowAdminAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowAdminAccess'
type MockRepoComponent_AllowAdminAccess_Call struct {
	*mock.Call
}

// AllowAdminAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - username string
func (_e *MockRepoComponent_Expecter) AllowAdminAccess(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, username interface{}) *MockRepoComponent_AllowAdminAccess_Call {
	return &MockRepoComponent_AllowAdminAccess_Call{Call: _e.mock.On("AllowAdminAccess", ctx, repoType, namespace, name, username)}
}

func (_c *MockRepoComponent_AllowAdminAccess_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, username string)) *MockRepoComponent_AllowAdminAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockRepoComponent_AllowAdminAccess_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_AllowAdminAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllowAdminAccess_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, string) (bool, error)) *MockRepoComponent_AllowAdminAccess_Call {
	_c.Call.Return(run)
	return _c
}

// AllowReadAccess provides a mock function with given fields: ctx, repoType, namespace, name, username
func (_m *MockRepoComponent) AllowReadAccess(ctx context.Context, repoType types.RepositoryType, namespace string, name string, username string) (bool, error) {
	ret := _m.Called(ctx, repoType, namespace, name, username)

	if len(ret) == 0 {
		panic("no return value specified for AllowReadAccess")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) (bool, error)); ok {
		return rf(ctx, repoType, namespace, name, username)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) bool); ok {
		r0 = rf(ctx, repoType, namespace, name, username)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, string, string) error); ok {
		r1 = rf(ctx, repoType, namespace, name, username)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllowReadAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowReadAccess'
type MockRepoComponent_AllowReadAccess_Call struct {
	*mock.Call
}

// AllowReadAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - username string
func (_e *MockRepoComponent_Expecter) AllowReadAccess(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, username interface{}) *MockRepoComponent_AllowReadAccess_Call {
	return &MockRepoComponent_AllowReadAccess_Call{Call: _e.mock.On("AllowReadAccess", ctx, repoType, namespace, name, username)}
}

func (_c *MockRepoComponent_AllowReadAccess_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, username string)) *MockRepoComponent_AllowReadAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockRepoComponent_AllowReadAccess_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_AllowReadAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllowReadAccess_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, string) (bool, error)) *MockRepoComponent_AllowReadAccess_Call {
	_c.Call.Return(run)
	return _c
}

// AllowReadAccessByDeployID provides a mock function with given fields: ctx, repoType, namespace, name, currentUser, deployID
func (_m *MockRepoComponent) AllowReadAccessByDeployID(ctx context.Context, repoType types.RepositoryType, namespace string, name string, currentUser string, deployID int64) (bool, error) {
	ret := _m.Called(ctx, repoType, namespace, name, currentUser, deployID)

	if len(ret) == 0 {
		panic("no return value specified for AllowReadAccessByDeployID")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string, int64) (bool, error)); ok {
		return rf(ctx, repoType, namespace, name, currentUser, deployID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string, int64) bool); ok {
		r0 = rf(ctx, repoType, namespace, name, currentUser, deployID)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, string, string, int64) error); ok {
		r1 = rf(ctx, repoType, namespace, name, currentUser, deployID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllowReadAccessByDeployID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowReadAccessByDeployID'
type MockRepoComponent_AllowReadAccessByDeployID_Call struct {
	*mock.Call
}

// AllowReadAccessByDeployID is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - currentUser string
//   - deployID int64
func (_e *MockRepoComponent_Expecter) AllowReadAccessByDeployID(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, currentUser interface{}, deployID interface{}) *MockRepoComponent_AllowReadAccessByDeployID_Call {
	return &MockRepoComponent_AllowReadAccessByDeployID_Call{Call: _e.mock.On("AllowReadAccessByDeployID", ctx, repoType, namespace, name, currentUser, deployID)}
}

func (_c *MockRepoComponent_AllowReadAccessByDeployID_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, currentUser string, deployID int64)) *MockRepoComponent_AllowReadAccessByDeployID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(string), args[5].(int64))
	})
	return _c
}

func (_c *MockRepoComponent_AllowReadAccessByDeployID_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_AllowReadAccessByDeployID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllowReadAccessByDeployID_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, string, int64) (bool, error)) *MockRepoComponent_AllowReadAccessByDeployID_Call {
	_c.Call.Return(run)
	return _c
}

// AllowReadAccessRepo provides a mock function with given fields: ctx, repo, username
func (_m *MockRepoComponent) AllowReadAccessRepo(ctx context.Context, repo *database.Repository, username string) (bool, error) {
	ret := _m.Called(ctx, repo, username)

	if len(ret) == 0 {
		panic("no return value specified for AllowReadAccessRepo")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *database.Repository, string) (bool, error)); ok {
		return rf(ctx, repo, username)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *database.Repository, string) bool); ok {
		r0 = rf(ctx, repo, username)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *database.Repository, string) error); ok {
		r1 = rf(ctx, repo, username)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllowReadAccessRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowReadAccessRepo'
type MockRepoComponent_AllowReadAccessRepo_Call struct {
	*mock.Call
}

// AllowReadAccessRepo is a helper method to define mock.On call
//   - ctx context.Context
//   - repo *database.Repository
//   - username string
func (_e *MockRepoComponent_Expecter) AllowReadAccessRepo(ctx interface{}, repo interface{}, username interface{}) *MockRepoComponent_AllowReadAccessRepo_Call {
	return &MockRepoComponent_AllowReadAccessRepo_Call{Call: _e.mock.On("AllowReadAccessRepo", ctx, repo, username)}
}

func (_c *MockRepoComponent_AllowReadAccessRepo_Call) Run(run func(ctx context.Context, repo *database.Repository, username string)) *MockRepoComponent_AllowReadAccessRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*database.Repository), args[2].(string))
	})
	return _c
}

func (_c *MockRepoComponent_AllowReadAccessRepo_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_AllowReadAccessRepo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllowReadAccessRepo_Call) RunAndReturn(run func(context.Context, *database.Repository, string) (bool, error)) *MockRepoComponent_AllowReadAccessRepo_Call {
	_c.Call.Return(run)
	return _c
}

// AllowWriteAccess provides a mock function with given fields: ctx, repoType, namespace, name, username
func (_m *MockRepoComponent) AllowWriteAccess(ctx context.Context, repoType types.RepositoryType, namespace string, name string, username string) (bool, error) {
	ret := _m.Called(ctx, repoType, namespace, name, username)

	if len(ret) == 0 {
		panic("no return value specified for AllowWriteAccess")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) (bool, error)); ok {
		return rf(ctx, repoType, namespace, name, username)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) bool); ok {
		r0 = rf(ctx, repoType, namespace, name, username)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, string, string) error); ok {
		r1 = rf(ctx, repoType, namespace, name, username)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_AllowWriteAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowWriteAccess'
type MockRepoComponent_AllowWriteAccess_Call struct {
	*mock.Call
}

// AllowWriteAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - username string
func (_e *MockRepoComponent_Expecter) AllowWriteAccess(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, username interface{}) *MockRepoComponent_AllowWriteAccess_Call {
	return &MockRepoComponent_AllowWriteAccess_Call{Call: _e.mock.On("AllowWriteAccess", ctx, repoType, namespace, name, username)}
}

func (_c *MockRepoComponent_AllowWriteAccess_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, username string)) *MockRepoComponent_AllowWriteAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockRepoComponent_AllowWriteAccess_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_AllowWriteAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_AllowWriteAccess_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, string) (bool, error)) *MockRepoComponent_AllowWriteAccess_Call {
	_c.Call.Return(run)
	return _c
}

// Branches provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) Branches(ctx context.Context, req *types.GetBranchesReq) ([]types.Branch, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for Branches")
	}

	var r0 []types.Branch
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetBranchesReq) ([]types.Branch, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetBranchesReq) []types.Branch); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.Branch)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetBranchesReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_Branches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Branches'
type MockRepoComponent_Branches_Call struct {
	*mock.Call
}

// Branches is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetBranchesReq
func (_e *MockRepoComponent_Expecter) Branches(ctx interface{}, req interface{}) *MockRepoComponent_Branches_Call {
	return &MockRepoComponent_Branches_Call{Call: _e.mock.On("Branches", ctx, req)}
}

func (_c *MockRepoComponent_Branches_Call) Run(run func(ctx context.Context, req *types.GetBranchesReq)) *MockRepoComponent_Branches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetBranchesReq))
	})
	return _c
}

func (_c *MockRepoComponent_Branches_Call) Return(_a0 []types.Branch, _a1 error) *MockRepoComponent_Branches_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_Branches_Call) RunAndReturn(run func(context.Context, *types.GetBranchesReq) ([]types.Branch, error)) *MockRepoComponent_Branches_Call {
	_c.Call.Return(run)
	return _c
}

// CheckCurrentUserPermission provides a mock function with given fields: ctx, userName, namespace, role
func (_m *MockRepoComponent) CheckCurrentUserPermission(ctx context.Context, userName string, namespace string, role membership.Role) (bool, error) {
	ret := _m.Called(ctx, userName, namespace, role)

	if len(ret) == 0 {
		panic("no return value specified for CheckCurrentUserPermission")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, membership.Role) (bool, error)); ok {
		return rf(ctx, userName, namespace, role)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, membership.Role) bool); ok {
		r0 = rf(ctx, userName, namespace, role)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, membership.Role) error); ok {
		r1 = rf(ctx, userName, namespace, role)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_CheckCurrentUserPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckCurrentUserPermission'
type MockRepoComponent_CheckCurrentUserPermission_Call struct {
	*mock.Call
}

// CheckCurrentUserPermission is a helper method to define mock.On call
//   - ctx context.Context
//   - userName string
//   - namespace string
//   - role membership.Role
func (_e *MockRepoComponent_Expecter) CheckCurrentUserPermission(ctx interface{}, userName interface{}, namespace interface{}, role interface{}) *MockRepoComponent_CheckCurrentUserPermission_Call {
	return &MockRepoComponent_CheckCurrentUserPermission_Call{Call: _e.mock.On("CheckCurrentUserPermission", ctx, userName, namespace, role)}
}

func (_c *MockRepoComponent_CheckCurrentUserPermission_Call) Run(run func(ctx context.Context, userName string, namespace string, role membership.Role)) *MockRepoComponent_CheckCurrentUserPermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(membership.Role))
	})
	return _c
}

func (_c *MockRepoComponent_CheckCurrentUserPermission_Call) Return(_a0 bool, _a1 error) *MockRepoComponent_CheckCurrentUserPermission_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_CheckCurrentUserPermission_Call) RunAndReturn(run func(context.Context, string, string, membership.Role) (bool, error)) *MockRepoComponent_CheckCurrentUserPermission_Call {
	_c.Call.Return(run)
	return _c
}

// Commits provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) Commits(ctx context.Context, req *types.GetCommitsReq) ([]types.Commit, *types.RepoPageOpts, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for Commits")
	}

	var r0 []types.Commit
	var r1 *types.RepoPageOpts
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetCommitsReq) ([]types.Commit, *types.RepoPageOpts, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetCommitsReq) []types.Commit); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.Commit)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetCommitsReq) *types.RepoPageOpts); ok {
		r1 = rf(ctx, req)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*types.RepoPageOpts)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, *types.GetCommitsReq) error); ok {
		r2 = rf(ctx, req)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// MockRepoComponent_Commits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Commits'
type MockRepoComponent_Commits_Call struct {
	*mock.Call
}

// Commits is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetCommitsReq
func (_e *MockRepoComponent_Expecter) Commits(ctx interface{}, req interface{}) *MockRepoComponent_Commits_Call {
	return &MockRepoComponent_Commits_Call{Call: _e.mock.On("Commits", ctx, req)}
}

func (_c *MockRepoComponent_Commits_Call) Run(run func(ctx context.Context, req *types.GetCommitsReq)) *MockRepoComponent_Commits_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetCommitsReq))
	})
	return _c
}

func (_c *MockRepoComponent_Commits_Call) Return(_a0 []types.Commit, _a1 *types.RepoPageOpts, _a2 error) *MockRepoComponent_Commits_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockRepoComponent_Commits_Call) RunAndReturn(run func(context.Context, *types.GetCommitsReq) ([]types.Commit, *types.RepoPageOpts, error)) *MockRepoComponent_Commits_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFile provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) CreateFile(ctx context.Context, req *types.CreateFileReq) (*types.CreateFileResp, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for CreateFile")
	}

	var r0 *types.CreateFileResp
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.CreateFileReq) (*types.CreateFileResp, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.CreateFileReq) *types.CreateFileResp); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.CreateFileResp)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.CreateFileReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_CreateFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFile'
type MockRepoComponent_CreateFile_Call struct {
	*mock.Call
}

// CreateFile is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.CreateFileReq
func (_e *MockRepoComponent_Expecter) CreateFile(ctx interface{}, req interface{}) *MockRepoComponent_CreateFile_Call {
	return &MockRepoComponent_CreateFile_Call{Call: _e.mock.On("CreateFile", ctx, req)}
}

func (_c *MockRepoComponent_CreateFile_Call) Run(run func(ctx context.Context, req *types.CreateFileReq)) *MockRepoComponent_CreateFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.CreateFileReq))
	})
	return _c
}

func (_c *MockRepoComponent_CreateFile_Call) Return(_a0 *types.CreateFileResp, _a1 error) *MockRepoComponent_CreateFile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_CreateFile_Call) RunAndReturn(run func(context.Context, *types.CreateFileReq) (*types.CreateFileResp, error)) *MockRepoComponent_CreateFile_Call {
	_c.Call.Return(run)
	return _c
}

// CreateMirror provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) CreateMirror(ctx context.Context, req types.CreateMirrorReq) (*database.Mirror, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for CreateMirror")
	}

	var r0 *database.Mirror
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.CreateMirrorReq) (*database.Mirror, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.CreateMirrorReq) *database.Mirror); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.Mirror)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.CreateMirrorReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_CreateMirror_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMirror'
type MockRepoComponent_CreateMirror_Call struct {
	*mock.Call
}

// CreateMirror is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.CreateMirrorReq
func (_e *MockRepoComponent_Expecter) CreateMirror(ctx interface{}, req interface{}) *MockRepoComponent_CreateMirror_Call {
	return &MockRepoComponent_CreateMirror_Call{Call: _e.mock.On("CreateMirror", ctx, req)}
}

func (_c *MockRepoComponent_CreateMirror_Call) Run(run func(ctx context.Context, req types.CreateMirrorReq)) *MockRepoComponent_CreateMirror_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.CreateMirrorReq))
	})
	return _c
}

func (_c *MockRepoComponent_CreateMirror_Call) Return(_a0 *database.Mirror, _a1 error) *MockRepoComponent_CreateMirror_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_CreateMirror_Call) RunAndReturn(run func(context.Context, types.CreateMirrorReq) (*database.Mirror, error)) *MockRepoComponent_CreateMirror_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRepo provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) CreateRepo(ctx context.Context, req types.CreateRepoReq) (*gitserver.CreateRepoResp, *database.Repository, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for CreateRepo")
	}

	var r0 *gitserver.CreateRepoResp
	var r1 *database.Repository
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, types.CreateRepoReq) (*gitserver.CreateRepoResp, *database.Repository, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.CreateRepoReq) *gitserver.CreateRepoResp); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gitserver.CreateRepoResp)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.CreateRepoReq) *database.Repository); ok {
		r1 = rf(ctx, req)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*database.Repository)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, types.CreateRepoReq) error); ok {
		r2 = rf(ctx, req)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// MockRepoComponent_CreateRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRepo'
type MockRepoComponent_CreateRepo_Call struct {
	*mock.Call
}

// CreateRepo is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.CreateRepoReq
func (_e *MockRepoComponent_Expecter) CreateRepo(ctx interface{}, req interface{}) *MockRepoComponent_CreateRepo_Call {
	return &MockRepoComponent_CreateRepo_Call{Call: _e.mock.On("CreateRepo", ctx, req)}
}

func (_c *MockRepoComponent_CreateRepo_Call) Run(run func(ctx context.Context, req types.CreateRepoReq)) *MockRepoComponent_CreateRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.CreateRepoReq))
	})
	return _c
}

func (_c *MockRepoComponent_CreateRepo_Call) Return(_a0 *gitserver.CreateRepoResp, _a1 *database.Repository, _a2 error) *MockRepoComponent_CreateRepo_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockRepoComponent_CreateRepo_Call) RunAndReturn(run func(context.Context, types.CreateRepoReq) (*gitserver.CreateRepoResp, *database.Repository, error)) *MockRepoComponent_CreateRepo_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRuntimeFramework provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) CreateRuntimeFramework(ctx context.Context, req *types.RuntimeFrameworkReq) (*types.RuntimeFramework, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for CreateRuntimeFramework")
	}

	var r0 *types.RuntimeFramework
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.RuntimeFrameworkReq) (*types.RuntimeFramework, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.RuntimeFrameworkReq) *types.RuntimeFramework); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.RuntimeFramework)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.RuntimeFrameworkReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_CreateRuntimeFramework_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRuntimeFramework'
type MockRepoComponent_CreateRuntimeFramework_Call struct {
	*mock.Call
}

// CreateRuntimeFramework is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.RuntimeFrameworkReq
func (_e *MockRepoComponent_Expecter) CreateRuntimeFramework(ctx interface{}, req interface{}) *MockRepoComponent_CreateRuntimeFramework_Call {
	return &MockRepoComponent_CreateRuntimeFramework_Call{Call: _e.mock.On("CreateRuntimeFramework", ctx, req)}
}

func (_c *MockRepoComponent_CreateRuntimeFramework_Call) Run(run func(ctx context.Context, req *types.RuntimeFrameworkReq)) *MockRepoComponent_CreateRuntimeFramework_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.RuntimeFrameworkReq))
	})
	return _c
}

func (_c *MockRepoComponent_CreateRuntimeFramework_Call) Return(_a0 *types.RuntimeFramework, _a1 error) *MockRepoComponent_CreateRuntimeFramework_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_CreateRuntimeFramework_Call) RunAndReturn(run func(context.Context, *types.RuntimeFrameworkReq) (*types.RuntimeFramework, error)) *MockRepoComponent_CreateRuntimeFramework_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDeploy provides a mock function with given fields: ctx, delReq
func (_m *MockRepoComponent) DeleteDeploy(ctx context.Context, delReq types.DeployActReq) error {
	ret := _m.Called(ctx, delReq)

	if len(ret) == 0 {
		panic("no return value specified for DeleteDeploy")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) error); ok {
		r0 = rf(ctx, delReq)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_DeleteDeploy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteDeploy'
type MockRepoComponent_DeleteDeploy_Call struct {
	*mock.Call
}

// DeleteDeploy is a helper method to define mock.On call
//   - ctx context.Context
//   - delReq types.DeployActReq
func (_e *MockRepoComponent_Expecter) DeleteDeploy(ctx interface{}, delReq interface{}) *MockRepoComponent_DeleteDeploy_Call {
	return &MockRepoComponent_DeleteDeploy_Call{Call: _e.mock.On("DeleteDeploy", ctx, delReq)}
}

func (_c *MockRepoComponent_DeleteDeploy_Call) Run(run func(ctx context.Context, delReq types.DeployActReq)) *MockRepoComponent_DeleteDeploy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeployActReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeleteDeploy_Call) Return(_a0 error) *MockRepoComponent_DeleteDeploy_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_DeleteDeploy_Call) RunAndReturn(run func(context.Context, types.DeployActReq) error) *MockRepoComponent_DeleteDeploy_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFile provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) DeleteFile(ctx context.Context, req *types.DeleteFileReq) (*types.DeleteFileResp, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for DeleteFile")
	}

	var r0 *types.DeleteFileResp
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.DeleteFileReq) (*types.DeleteFileResp, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.DeleteFileReq) *types.DeleteFileResp); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.DeleteFileResp)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.DeleteFileReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_DeleteFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFile'
type MockRepoComponent_DeleteFile_Call struct {
	*mock.Call
}

// DeleteFile is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.DeleteFileReq
func (_e *MockRepoComponent_Expecter) DeleteFile(ctx interface{}, req interface{}) *MockRepoComponent_DeleteFile_Call {
	return &MockRepoComponent_DeleteFile_Call{Call: _e.mock.On("DeleteFile", ctx, req)}
}

func (_c *MockRepoComponent_DeleteFile_Call) Run(run func(ctx context.Context, req *types.DeleteFileReq)) *MockRepoComponent_DeleteFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.DeleteFileReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeleteFile_Call) Return(_a0 *types.DeleteFileResp, _a1 error) *MockRepoComponent_DeleteFile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_DeleteFile_Call) RunAndReturn(run func(context.Context, *types.DeleteFileReq) (*types.DeleteFileResp, error)) *MockRepoComponent_DeleteFile_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMirror provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) DeleteMirror(ctx context.Context, req types.DeleteMirrorReq) error {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for DeleteMirror")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeleteMirrorReq) error); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_DeleteMirror_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMirror'
type MockRepoComponent_DeleteMirror_Call struct {
	*mock.Call
}

// DeleteMirror is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.DeleteMirrorReq
func (_e *MockRepoComponent_Expecter) DeleteMirror(ctx interface{}, req interface{}) *MockRepoComponent_DeleteMirror_Call {
	return &MockRepoComponent_DeleteMirror_Call{Call: _e.mock.On("DeleteMirror", ctx, req)}
}

func (_c *MockRepoComponent_DeleteMirror_Call) Run(run func(ctx context.Context, req types.DeleteMirrorReq)) *MockRepoComponent_DeleteMirror_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeleteMirrorReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeleteMirror_Call) Return(_a0 error) *MockRepoComponent_DeleteMirror_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_DeleteMirror_Call) RunAndReturn(run func(context.Context, types.DeleteMirrorReq) error) *MockRepoComponent_DeleteMirror_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRepo provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) DeleteRepo(ctx context.Context, req types.DeleteRepoReq) (*database.Repository, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRepo")
	}

	var r0 *database.Repository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeleteRepoReq) (*database.Repository, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.DeleteRepoReq) *database.Repository); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.Repository)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.DeleteRepoReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_DeleteRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRepo'
type MockRepoComponent_DeleteRepo_Call struct {
	*mock.Call
}

// DeleteRepo is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.DeleteRepoReq
func (_e *MockRepoComponent_Expecter) DeleteRepo(ctx interface{}, req interface{}) *MockRepoComponent_DeleteRepo_Call {
	return &MockRepoComponent_DeleteRepo_Call{Call: _e.mock.On("DeleteRepo", ctx, req)}
}

func (_c *MockRepoComponent_DeleteRepo_Call) Run(run func(ctx context.Context, req types.DeleteRepoReq)) *MockRepoComponent_DeleteRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeleteRepoReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeleteRepo_Call) Return(_a0 *database.Repository, _a1 error) *MockRepoComponent_DeleteRepo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_DeleteRepo_Call) RunAndReturn(run func(context.Context, types.DeleteRepoReq) (*database.Repository, error)) *MockRepoComponent_DeleteRepo_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRuntimeFramework provides a mock function with given fields: ctx, id
func (_m *MockRepoComponent) DeleteRuntimeFramework(ctx context.Context, id int64) error {
	ret := _m.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRuntimeFramework")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_DeleteRuntimeFramework_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRuntimeFramework'
type MockRepoComponent_DeleteRuntimeFramework_Call struct {
	*mock.Call
}

// DeleteRuntimeFramework is a helper method to define mock.On call
//   - ctx context.Context
//   - id int64
func (_e *MockRepoComponent_Expecter) DeleteRuntimeFramework(ctx interface{}, id interface{}) *MockRepoComponent_DeleteRuntimeFramework_Call {
	return &MockRepoComponent_DeleteRuntimeFramework_Call{Call: _e.mock.On("DeleteRuntimeFramework", ctx, id)}
}

func (_c *MockRepoComponent_DeleteRuntimeFramework_Call) Run(run func(ctx context.Context, id int64)) *MockRepoComponent_DeleteRuntimeFramework_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64))
	})
	return _c
}

func (_c *MockRepoComponent_DeleteRuntimeFramework_Call) Return(_a0 error) *MockRepoComponent_DeleteRuntimeFramework_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_DeleteRuntimeFramework_Call) RunAndReturn(run func(context.Context, int64) error) *MockRepoComponent_DeleteRuntimeFramework_Call {
	_c.Call.Return(run)
	return _c
}

// DeployDetail provides a mock function with given fields: ctx, detailReq
func (_m *MockRepoComponent) DeployDetail(ctx context.Context, detailReq types.DeployActReq) (*types.DeployRepo, error) {
	ret := _m.Called(ctx, detailReq)

	if len(ret) == 0 {
		panic("no return value specified for DeployDetail")
	}

	var r0 *types.DeployRepo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) (*types.DeployRepo, error)); ok {
		return rf(ctx, detailReq)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) *types.DeployRepo); ok {
		r0 = rf(ctx, detailReq)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.DeployRepo)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.DeployActReq) error); ok {
		r1 = rf(ctx, detailReq)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_DeployDetail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployDetail'
type MockRepoComponent_DeployDetail_Call struct {
	*mock.Call
}

// DeployDetail is a helper method to define mock.On call
//   - ctx context.Context
//   - detailReq types.DeployActReq
func (_e *MockRepoComponent_Expecter) DeployDetail(ctx interface{}, detailReq interface{}) *MockRepoComponent_DeployDetail_Call {
	return &MockRepoComponent_DeployDetail_Call{Call: _e.mock.On("DeployDetail", ctx, detailReq)}
}

func (_c *MockRepoComponent_DeployDetail_Call) Run(run func(ctx context.Context, detailReq types.DeployActReq)) *MockRepoComponent_DeployDetail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeployActReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeployDetail_Call) Return(_a0 *types.DeployRepo, _a1 error) *MockRepoComponent_DeployDetail_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_DeployDetail_Call) RunAndReturn(run func(context.Context, types.DeployActReq) (*types.DeployRepo, error)) *MockRepoComponent_DeployDetail_Call {
	_c.Call.Return(run)
	return _c
}

// DeployInstanceLogs provides a mock function with given fields: ctx, logReq
func (_m *MockRepoComponent) DeployInstanceLogs(ctx context.Context, logReq types.DeployActReq) (*deploy.MultiLogReader, error) {
	ret := _m.Called(ctx, logReq)

	if len(ret) == 0 {
		panic("no return value specified for DeployInstanceLogs")
	}

	var r0 *deploy.MultiLogReader
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) (*deploy.MultiLogReader, error)); ok {
		return rf(ctx, logReq)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) *deploy.MultiLogReader); ok {
		r0 = rf(ctx, logReq)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*deploy.MultiLogReader)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.DeployActReq) error); ok {
		r1 = rf(ctx, logReq)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_DeployInstanceLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployInstanceLogs'
type MockRepoComponent_DeployInstanceLogs_Call struct {
	*mock.Call
}

// DeployInstanceLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - logReq types.DeployActReq
func (_e *MockRepoComponent_Expecter) DeployInstanceLogs(ctx interface{}, logReq interface{}) *MockRepoComponent_DeployInstanceLogs_Call {
	return &MockRepoComponent_DeployInstanceLogs_Call{Call: _e.mock.On("DeployInstanceLogs", ctx, logReq)}
}

func (_c *MockRepoComponent_DeployInstanceLogs_Call) Run(run func(ctx context.Context, logReq types.DeployActReq)) *MockRepoComponent_DeployInstanceLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeployActReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeployInstanceLogs_Call) Return(_a0 *deploy.MultiLogReader, _a1 error) *MockRepoComponent_DeployInstanceLogs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_DeployInstanceLogs_Call) RunAndReturn(run func(context.Context, types.DeployActReq) (*deploy.MultiLogReader, error)) *MockRepoComponent_DeployInstanceLogs_Call {
	_c.Call.Return(run)
	return _c
}

// DeployStart provides a mock function with given fields: ctx, startReq
func (_m *MockRepoComponent) DeployStart(ctx context.Context, startReq types.DeployActReq) error {
	ret := _m.Called(ctx, startReq)

	if len(ret) == 0 {
		panic("no return value specified for DeployStart")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) error); ok {
		r0 = rf(ctx, startReq)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_DeployStart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployStart'
type MockRepoComponent_DeployStart_Call struct {
	*mock.Call
}

// DeployStart is a helper method to define mock.On call
//   - ctx context.Context
//   - startReq types.DeployActReq
func (_e *MockRepoComponent_Expecter) DeployStart(ctx interface{}, startReq interface{}) *MockRepoComponent_DeployStart_Call {
	return &MockRepoComponent_DeployStart_Call{Call: _e.mock.On("DeployStart", ctx, startReq)}
}

func (_c *MockRepoComponent_DeployStart_Call) Run(run func(ctx context.Context, startReq types.DeployActReq)) *MockRepoComponent_DeployStart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeployActReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeployStart_Call) Return(_a0 error) *MockRepoComponent_DeployStart_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_DeployStart_Call) RunAndReturn(run func(context.Context, types.DeployActReq) error) *MockRepoComponent_DeployStart_Call {
	_c.Call.Return(run)
	return _c
}

// DeployStatus provides a mock function with given fields: ctx, repoType, namespace, name, deployID
func (_m *MockRepoComponent) DeployStatus(ctx context.Context, repoType types.RepositoryType, namespace string, name string, deployID int64) (string, string, []types.Instance, error) {
	ret := _m.Called(ctx, repoType, namespace, name, deployID)

	if len(ret) == 0 {
		panic("no return value specified for DeployStatus")
	}

	var r0 string
	var r1 string
	var r2 []types.Instance
	var r3 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, int64) (string, string, []types.Instance, error)); ok {
		return rf(ctx, repoType, namespace, name, deployID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, int64) string); ok {
		r0 = rf(ctx, repoType, namespace, name, deployID)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, string, int64) string); ok {
		r1 = rf(ctx, repoType, namespace, name, deployID)
	} else {
		r1 = ret.Get(1).(string)
	}

	if rf, ok := ret.Get(2).(func(context.Context, types.RepositoryType, string, string, int64) []types.Instance); ok {
		r2 = rf(ctx, repoType, namespace, name, deployID)
	} else {
		if ret.Get(2) != nil {
			r2 = ret.Get(2).([]types.Instance)
		}
	}

	if rf, ok := ret.Get(3).(func(context.Context, types.RepositoryType, string, string, int64) error); ok {
		r3 = rf(ctx, repoType, namespace, name, deployID)
	} else {
		r3 = ret.Error(3)
	}

	return r0, r1, r2, r3
}

// MockRepoComponent_DeployStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployStatus'
type MockRepoComponent_DeployStatus_Call struct {
	*mock.Call
}

// DeployStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - deployID int64
func (_e *MockRepoComponent_Expecter) DeployStatus(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, deployID interface{}) *MockRepoComponent_DeployStatus_Call {
	return &MockRepoComponent_DeployStatus_Call{Call: _e.mock.On("DeployStatus", ctx, repoType, namespace, name, deployID)}
}

func (_c *MockRepoComponent_DeployStatus_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, deployID int64)) *MockRepoComponent_DeployStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(int64))
	})
	return _c
}

func (_c *MockRepoComponent_DeployStatus_Call) Return(_a0 string, _a1 string, _a2 []types.Instance, _a3 error) *MockRepoComponent_DeployStatus_Call {
	_c.Call.Return(_a0, _a1, _a2, _a3)
	return _c
}

func (_c *MockRepoComponent_DeployStatus_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, int64) (string, string, []types.Instance, error)) *MockRepoComponent_DeployStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DeployStop provides a mock function with given fields: ctx, stopReq
func (_m *MockRepoComponent) DeployStop(ctx context.Context, stopReq types.DeployActReq) error {
	ret := _m.Called(ctx, stopReq)

	if len(ret) == 0 {
		panic("no return value specified for DeployStop")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq) error); ok {
		r0 = rf(ctx, stopReq)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_DeployStop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployStop'
type MockRepoComponent_DeployStop_Call struct {
	*mock.Call
}

// DeployStop is a helper method to define mock.On call
//   - ctx context.Context
//   - stopReq types.DeployActReq
func (_e *MockRepoComponent_Expecter) DeployStop(ctx interface{}, stopReq interface{}) *MockRepoComponent_DeployStop_Call {
	return &MockRepoComponent_DeployStop_Call{Call: _e.mock.On("DeployStop", ctx, stopReq)}
}

func (_c *MockRepoComponent_DeployStop_Call) Run(run func(ctx context.Context, stopReq types.DeployActReq)) *MockRepoComponent_DeployStop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeployActReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeployStop_Call) Return(_a0 error) *MockRepoComponent_DeployStop_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_DeployStop_Call) RunAndReturn(run func(context.Context, types.DeployActReq) error) *MockRepoComponent_DeployStop_Call {
	_c.Call.Return(run)
	return _c
}

// DeployUpdate provides a mock function with given fields: ctx, updateReq, req
func (_m *MockRepoComponent) DeployUpdate(ctx context.Context, updateReq types.DeployActReq, req *types.DeployUpdateReq) error {
	ret := _m.Called(ctx, updateReq, req)

	if len(ret) == 0 {
		panic("no return value specified for DeployUpdate")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.DeployActReq, *types.DeployUpdateReq) error); ok {
		r0 = rf(ctx, updateReq, req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_DeployUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployUpdate'
type MockRepoComponent_DeployUpdate_Call struct {
	*mock.Call
}

// DeployUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - updateReq types.DeployActReq
//   - req *types.DeployUpdateReq
func (_e *MockRepoComponent_Expecter) DeployUpdate(ctx interface{}, updateReq interface{}, req interface{}) *MockRepoComponent_DeployUpdate_Call {
	return &MockRepoComponent_DeployUpdate_Call{Call: _e.mock.On("DeployUpdate", ctx, updateReq, req)}
}

func (_c *MockRepoComponent_DeployUpdate_Call) Run(run func(ctx context.Context, updateReq types.DeployActReq, req *types.DeployUpdateReq)) *MockRepoComponent_DeployUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.DeployActReq), args[2].(*types.DeployUpdateReq))
	})
	return _c
}

func (_c *MockRepoComponent_DeployUpdate_Call) Return(_a0 error) *MockRepoComponent_DeployUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_DeployUpdate_Call) RunAndReturn(run func(context.Context, types.DeployActReq, *types.DeployUpdateReq) error) *MockRepoComponent_DeployUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadFile provides a mock function with given fields: ctx, req, userName
func (_m *MockRepoComponent) DownloadFile(ctx context.Context, req *types.GetFileReq, userName string) (io.ReadCloser, int64, string, error) {
	ret := _m.Called(ctx, req, userName)

	if len(ret) == 0 {
		panic("no return value specified for DownloadFile")
	}

	var r0 io.ReadCloser
	var r1 int64
	var r2 string
	var r3 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq, string) (io.ReadCloser, int64, string, error)); ok {
		return rf(ctx, req, userName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq, string) io.ReadCloser); ok {
		r0 = rf(ctx, req, userName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetFileReq, string) int64); ok {
		r1 = rf(ctx, req, userName)
	} else {
		r1 = ret.Get(1).(int64)
	}

	if rf, ok := ret.Get(2).(func(context.Context, *types.GetFileReq, string) string); ok {
		r2 = rf(ctx, req, userName)
	} else {
		r2 = ret.Get(2).(string)
	}

	if rf, ok := ret.Get(3).(func(context.Context, *types.GetFileReq, string) error); ok {
		r3 = rf(ctx, req, userName)
	} else {
		r3 = ret.Error(3)
	}

	return r0, r1, r2, r3
}

// MockRepoComponent_DownloadFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadFile'
type MockRepoComponent_DownloadFile_Call struct {
	*mock.Call
}

// DownloadFile is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetFileReq
//   - userName string
func (_e *MockRepoComponent_Expecter) DownloadFile(ctx interface{}, req interface{}, userName interface{}) *MockRepoComponent_DownloadFile_Call {
	return &MockRepoComponent_DownloadFile_Call{Call: _e.mock.On("DownloadFile", ctx, req, userName)}
}

func (_c *MockRepoComponent_DownloadFile_Call) Run(run func(ctx context.Context, req *types.GetFileReq, userName string)) *MockRepoComponent_DownloadFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetFileReq), args[2].(string))
	})
	return _c
}

func (_c *MockRepoComponent_DownloadFile_Call) Return(_a0 io.ReadCloser, _a1 int64, _a2 string, _a3 error) *MockRepoComponent_DownloadFile_Call {
	_c.Call.Return(_a0, _a1, _a2, _a3)
	return _c
}

func (_c *MockRepoComponent_DownloadFile_Call) RunAndReturn(run func(context.Context, *types.GetFileReq, string) (io.ReadCloser, int64, string, error)) *MockRepoComponent_DownloadFile_Call {
	_c.Call.Return(run)
	return _c
}

// FileInfo provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) FileInfo(ctx context.Context, req *types.GetFileReq) (*types.File, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for FileInfo")
	}

	var r0 *types.File
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq) (*types.File, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq) *types.File); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.File)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetFileReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_FileInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FileInfo'
type MockRepoComponent_FileInfo_Call struct {
	*mock.Call
}

// FileInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetFileReq
func (_e *MockRepoComponent_Expecter) FileInfo(ctx interface{}, req interface{}) *MockRepoComponent_FileInfo_Call {
	return &MockRepoComponent_FileInfo_Call{Call: _e.mock.On("FileInfo", ctx, req)}
}

func (_c *MockRepoComponent_FileInfo_Call) Run(run func(ctx context.Context, req *types.GetFileReq)) *MockRepoComponent_FileInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetFileReq))
	})
	return _c
}

func (_c *MockRepoComponent_FileInfo_Call) Return(_a0 *types.File, _a1 error) *MockRepoComponent_FileInfo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_FileInfo_Call) RunAndReturn(run func(context.Context, *types.GetFileReq) (*types.File, error)) *MockRepoComponent_FileInfo_Call {
	_c.Call.Return(run)
	return _c
}

// FileRaw provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) FileRaw(ctx context.Context, req *types.GetFileReq) (string, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for FileRaw")
	}

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq) (string, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq) string); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetFileReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_FileRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FileRaw'
type MockRepoComponent_FileRaw_Call struct {
	*mock.Call
}

// FileRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetFileReq
func (_e *MockRepoComponent_Expecter) FileRaw(ctx interface{}, req interface{}) *MockRepoComponent_FileRaw_Call {
	return &MockRepoComponent_FileRaw_Call{Call: _e.mock.On("FileRaw", ctx, req)}
}

func (_c *MockRepoComponent_FileRaw_Call) Run(run func(ctx context.Context, req *types.GetFileReq)) *MockRepoComponent_FileRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetFileReq))
	})
	return _c
}

func (_c *MockRepoComponent_FileRaw_Call) Return(_a0 string, _a1 error) *MockRepoComponent_FileRaw_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_FileRaw_Call) RunAndReturn(run func(context.Context, *types.GetFileReq) (string, error)) *MockRepoComponent_FileRaw_Call {
	_c.Call.Return(run)
	return _c
}

// GetCommitWithDiff provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) GetCommitWithDiff(ctx context.Context, req *types.GetCommitsReq) (*types.CommitResponse, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for GetCommitWithDiff")
	}

	var r0 *types.CommitResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetCommitsReq) (*types.CommitResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetCommitsReq) *types.CommitResponse); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.CommitResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetCommitsReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_GetCommitWithDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCommitWithDiff'
type MockRepoComponent_GetCommitWithDiff_Call struct {
	*mock.Call
}

// GetCommitWithDiff is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetCommitsReq
func (_e *MockRepoComponent_Expecter) GetCommitWithDiff(ctx interface{}, req interface{}) *MockRepoComponent_GetCommitWithDiff_Call {
	return &MockRepoComponent_GetCommitWithDiff_Call{Call: _e.mock.On("GetCommitWithDiff", ctx, req)}
}

func (_c *MockRepoComponent_GetCommitWithDiff_Call) Run(run func(ctx context.Context, req *types.GetCommitsReq)) *MockRepoComponent_GetCommitWithDiff_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetCommitsReq))
	})
	return _c
}

func (_c *MockRepoComponent_GetCommitWithDiff_Call) Return(_a0 *types.CommitResponse, _a1 error) *MockRepoComponent_GetCommitWithDiff_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_GetCommitWithDiff_Call) RunAndReturn(run func(context.Context, *types.GetCommitsReq) (*types.CommitResponse, error)) *MockRepoComponent_GetCommitWithDiff_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeployBySvcName provides a mock function with given fields: ctx, svcName
func (_m *MockRepoComponent) GetDeployBySvcName(ctx context.Context, svcName string) (*database.Deploy, error) {
	ret := _m.Called(ctx, svcName)

	if len(ret) == 0 {
		panic("no return value specified for GetDeployBySvcName")
	}

	var r0 *database.Deploy
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*database.Deploy, error)); ok {
		return rf(ctx, svcName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *database.Deploy); ok {
		r0 = rf(ctx, svcName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.Deploy)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, svcName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_GetDeployBySvcName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeployBySvcName'
type MockRepoComponent_GetDeployBySvcName_Call struct {
	*mock.Call
}

// GetDeployBySvcName is a helper method to define mock.On call
//   - ctx context.Context
//   - svcName string
func (_e *MockRepoComponent_Expecter) GetDeployBySvcName(ctx interface{}, svcName interface{}) *MockRepoComponent_GetDeployBySvcName_Call {
	return &MockRepoComponent_GetDeployBySvcName_Call{Call: _e.mock.On("GetDeployBySvcName", ctx, svcName)}
}

func (_c *MockRepoComponent_GetDeployBySvcName_Call) Run(run func(ctx context.Context, svcName string)) *MockRepoComponent_GetDeployBySvcName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockRepoComponent_GetDeployBySvcName_Call) Return(_a0 *database.Deploy, _a1 error) *MockRepoComponent_GetDeployBySvcName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_GetDeployBySvcName_Call) RunAndReturn(run func(context.Context, string) (*database.Deploy, error)) *MockRepoComponent_GetDeployBySvcName_Call {
	_c.Call.Return(run)
	return _c
}

// GetMirror provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) GetMirror(ctx context.Context, req types.GetMirrorReq) (*database.Mirror, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for GetMirror")
	}

	var r0 *database.Mirror
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.GetMirrorReq) (*database.Mirror, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.GetMirrorReq) *database.Mirror); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.Mirror)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.GetMirrorReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_GetMirror_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMirror'
type MockRepoComponent_GetMirror_Call struct {
	*mock.Call
}

// GetMirror is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.GetMirrorReq
func (_e *MockRepoComponent_Expecter) GetMirror(ctx interface{}, req interface{}) *MockRepoComponent_GetMirror_Call {
	return &MockRepoComponent_GetMirror_Call{Call: _e.mock.On("GetMirror", ctx, req)}
}

func (_c *MockRepoComponent_GetMirror_Call) Run(run func(ctx context.Context, req types.GetMirrorReq)) *MockRepoComponent_GetMirror_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.GetMirrorReq))
	})
	return _c
}

func (_c *MockRepoComponent_GetMirror_Call) Return(_a0 *database.Mirror, _a1 error) *MockRepoComponent_GetMirror_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_GetMirror_Call) RunAndReturn(run func(context.Context, types.GetMirrorReq) (*database.Mirror, error)) *MockRepoComponent_GetMirror_Call {
	_c.Call.Return(run)
	return _c
}

// GetNameSpaceInfo provides a mock function with given fields: ctx, path
func (_m *MockRepoComponent) GetNameSpaceInfo(ctx context.Context, path string) (*types.Namespace, error) {
	ret := _m.Called(ctx, path)

	if len(ret) == 0 {
		panic("no return value specified for GetNameSpaceInfo")
	}

	var r0 *types.Namespace
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*types.Namespace, error)); ok {
		return rf(ctx, path)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *types.Namespace); ok {
		r0 = rf(ctx, path)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Namespace)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, path)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_GetNameSpaceInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNameSpaceInfo'
type MockRepoComponent_GetNameSpaceInfo_Call struct {
	*mock.Call
}

// GetNameSpaceInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - path string
func (_e *MockRepoComponent_Expecter) GetNameSpaceInfo(ctx interface{}, path interface{}) *MockRepoComponent_GetNameSpaceInfo_Call {
	return &MockRepoComponent_GetNameSpaceInfo_Call{Call: _e.mock.On("GetNameSpaceInfo", ctx, path)}
}

func (_c *MockRepoComponent_GetNameSpaceInfo_Call) Run(run func(ctx context.Context, path string)) *MockRepoComponent_GetNameSpaceInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockRepoComponent_GetNameSpaceInfo_Call) Return(_a0 *types.Namespace, _a1 error) *MockRepoComponent_GetNameSpaceInfo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_GetNameSpaceInfo_Call) RunAndReturn(run func(context.Context, string) (*types.Namespace, error)) *MockRepoComponent_GetNameSpaceInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserRepoPermission provides a mock function with given fields: ctx, userName, repo
func (_m *MockRepoComponent) GetUserRepoPermission(ctx context.Context, userName string, repo *database.Repository) (*types.UserRepoPermission, error) {
	ret := _m.Called(ctx, userName, repo)

	if len(ret) == 0 {
		panic("no return value specified for GetUserRepoPermission")
	}

	var r0 *types.UserRepoPermission
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *database.Repository) (*types.UserRepoPermission, error)); ok {
		return rf(ctx, userName, repo)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *database.Repository) *types.UserRepoPermission); ok {
		r0 = rf(ctx, userName, repo)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.UserRepoPermission)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *database.Repository) error); ok {
		r1 = rf(ctx, userName, repo)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_GetUserRepoPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserRepoPermission'
type MockRepoComponent_GetUserRepoPermission_Call struct {
	*mock.Call
}

// GetUserRepoPermission is a helper method to define mock.On call
//   - ctx context.Context
//   - userName string
//   - repo *database.Repository
func (_e *MockRepoComponent_Expecter) GetUserRepoPermission(ctx interface{}, userName interface{}, repo interface{}) *MockRepoComponent_GetUserRepoPermission_Call {
	return &MockRepoComponent_GetUserRepoPermission_Call{Call: _e.mock.On("GetUserRepoPermission", ctx, userName, repo)}
}

func (_c *MockRepoComponent_GetUserRepoPermission_Call) Run(run func(ctx context.Context, userName string, repo *database.Repository)) *MockRepoComponent_GetUserRepoPermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*database.Repository))
	})
	return _c
}

func (_c *MockRepoComponent_GetUserRepoPermission_Call) Return(_a0 *types.UserRepoPermission, _a1 error) *MockRepoComponent_GetUserRepoPermission_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_GetUserRepoPermission_Call) RunAndReturn(run func(context.Context, string, *database.Repository) (*types.UserRepoPermission, error)) *MockRepoComponent_GetUserRepoPermission_Call {
	_c.Call.Return(run)
	return _c
}

// HeadDownloadFile provides a mock function with given fields: ctx, req, userName
func (_m *MockRepoComponent) HeadDownloadFile(ctx context.Context, req *types.GetFileReq, userName string) (*types.File, error) {
	ret := _m.Called(ctx, req, userName)

	if len(ret) == 0 {
		panic("no return value specified for HeadDownloadFile")
	}

	var r0 *types.File
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq, string) (*types.File, error)); ok {
		return rf(ctx, req, userName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq, string) *types.File); ok {
		r0 = rf(ctx, req, userName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.File)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetFileReq, string) error); ok {
		r1 = rf(ctx, req, userName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_HeadDownloadFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadDownloadFile'
type MockRepoComponent_HeadDownloadFile_Call struct {
	*mock.Call
}

// HeadDownloadFile is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetFileReq
//   - userName string
func (_e *MockRepoComponent_Expecter) HeadDownloadFile(ctx interface{}, req interface{}, userName interface{}) *MockRepoComponent_HeadDownloadFile_Call {
	return &MockRepoComponent_HeadDownloadFile_Call{Call: _e.mock.On("HeadDownloadFile", ctx, req, userName)}
}

func (_c *MockRepoComponent_HeadDownloadFile_Call) Run(run func(ctx context.Context, req *types.GetFileReq, userName string)) *MockRepoComponent_HeadDownloadFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetFileReq), args[2].(string))
	})
	return _c
}

func (_c *MockRepoComponent_HeadDownloadFile_Call) Return(_a0 *types.File, _a1 error) *MockRepoComponent_HeadDownloadFile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_HeadDownloadFile_Call) RunAndReturn(run func(context.Context, *types.GetFileReq, string) (*types.File, error)) *MockRepoComponent_HeadDownloadFile_Call {
	_c.Call.Return(run)
	return _c
}

// IncrDownloads provides a mock function with given fields: ctx, repoType, namespace, name
func (_m *MockRepoComponent) IncrDownloads(ctx context.Context, repoType types.RepositoryType, namespace string, name string) error {
	ret := _m.Called(ctx, repoType, namespace, name)

	if len(ret) == 0 {
		panic("no return value specified for IncrDownloads")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string) error); ok {
		r0 = rf(ctx, repoType, namespace, name)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_IncrDownloads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrDownloads'
type MockRepoComponent_IncrDownloads_Call struct {
	*mock.Call
}

// IncrDownloads is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
func (_e *MockRepoComponent_Expecter) IncrDownloads(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}) *MockRepoComponent_IncrDownloads_Call {
	return &MockRepoComponent_IncrDownloads_Call{Call: _e.mock.On("IncrDownloads", ctx, repoType, namespace, name)}
}

func (_c *MockRepoComponent_IncrDownloads_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string)) *MockRepoComponent_IncrDownloads_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockRepoComponent_IncrDownloads_Call) Return(_a0 error) *MockRepoComponent_IncrDownloads_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_IncrDownloads_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string) error) *MockRepoComponent_IncrDownloads_Call {
	_c.Call.Return(run)
	return _c
}

// IsLfs provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) IsLfs(ctx context.Context, req *types.GetFileReq) (bool, int64, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for IsLfs")
	}

	var r0 bool
	var r1 int64
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq) (bool, int64, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq) bool); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetFileReq) int64); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Get(1).(int64)
	}

	if rf, ok := ret.Get(2).(func(context.Context, *types.GetFileReq) error); ok {
		r2 = rf(ctx, req)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// MockRepoComponent_IsLfs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLfs'
type MockRepoComponent_IsLfs_Call struct {
	*mock.Call
}

// IsLfs is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetFileReq
func (_e *MockRepoComponent_Expecter) IsLfs(ctx interface{}, req interface{}) *MockRepoComponent_IsLfs_Call {
	return &MockRepoComponent_IsLfs_Call{Call: _e.mock.On("IsLfs", ctx, req)}
}

func (_c *MockRepoComponent_IsLfs_Call) Run(run func(ctx context.Context, req *types.GetFileReq)) *MockRepoComponent_IsLfs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetFileReq))
	})
	return _c
}

func (_c *MockRepoComponent_IsLfs_Call) Return(_a0 bool, _a1 int64, _a2 error) *MockRepoComponent_IsLfs_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockRepoComponent_IsLfs_Call) RunAndReturn(run func(context.Context, *types.GetFileReq) (bool, int64, error)) *MockRepoComponent_IsLfs_Call {
	_c.Call.Return(run)
	return _c
}

// LastCommit provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) LastCommit(ctx context.Context, req *types.GetCommitsReq) (*types.Commit, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for LastCommit")
	}

	var r0 *types.Commit
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetCommitsReq) (*types.Commit, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetCommitsReq) *types.Commit); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Commit)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetCommitsReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_LastCommit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastCommit'
type MockRepoComponent_LastCommit_Call struct {
	*mock.Call
}

// LastCommit is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetCommitsReq
func (_e *MockRepoComponent_Expecter) LastCommit(ctx interface{}, req interface{}) *MockRepoComponent_LastCommit_Call {
	return &MockRepoComponent_LastCommit_Call{Call: _e.mock.On("LastCommit", ctx, req)}
}

func (_c *MockRepoComponent_LastCommit_Call) Run(run func(ctx context.Context, req *types.GetCommitsReq)) *MockRepoComponent_LastCommit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetCommitsReq))
	})
	return _c
}

func (_c *MockRepoComponent_LastCommit_Call) Return(_a0 *types.Commit, _a1 error) *MockRepoComponent_LastCommit_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_LastCommit_Call) RunAndReturn(run func(context.Context, *types.GetCommitsReq) (*types.Commit, error)) *MockRepoComponent_LastCommit_Call {
	_c.Call.Return(run)
	return _c
}

// ListDeploy provides a mock function with given fields: ctx, repoType, namespace, name, currentUser
func (_m *MockRepoComponent) ListDeploy(ctx context.Context, repoType types.RepositoryType, namespace string, name string, currentUser string) ([]types.DeployRepo, error) {
	ret := _m.Called(ctx, repoType, namespace, name, currentUser)

	if len(ret) == 0 {
		panic("no return value specified for ListDeploy")
	}

	var r0 []types.DeployRepo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) ([]types.DeployRepo, error)); ok {
		return rf(ctx, repoType, namespace, name, currentUser)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) []types.DeployRepo); ok {
		r0 = rf(ctx, repoType, namespace, name, currentUser)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.DeployRepo)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, string, string) error); ok {
		r1 = rf(ctx, repoType, namespace, name, currentUser)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_ListDeploy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDeploy'
type MockRepoComponent_ListDeploy_Call struct {
	*mock.Call
}

// ListDeploy is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - currentUser string
func (_e *MockRepoComponent_Expecter) ListDeploy(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, currentUser interface{}) *MockRepoComponent_ListDeploy_Call {
	return &MockRepoComponent_ListDeploy_Call{Call: _e.mock.On("ListDeploy", ctx, repoType, namespace, name, currentUser)}
}

func (_c *MockRepoComponent_ListDeploy_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, currentUser string)) *MockRepoComponent_ListDeploy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockRepoComponent_ListDeploy_Call) Return(_a0 []types.DeployRepo, _a1 error) *MockRepoComponent_ListDeploy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_ListDeploy_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, string) ([]types.DeployRepo, error)) *MockRepoComponent_ListDeploy_Call {
	_c.Call.Return(run)
	return _c
}

// ListRuntimeFramework provides a mock function with given fields: ctx, repoType, namespace, name, deployType
func (_m *MockRepoComponent) ListRuntimeFramework(ctx context.Context, repoType types.RepositoryType, namespace string, name string, deployType int) ([]types.RuntimeFramework, error) {
	ret := _m.Called(ctx, repoType, namespace, name, deployType)

	if len(ret) == 0 {
		panic("no return value specified for ListRuntimeFramework")
	}

	var r0 []types.RuntimeFramework
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, int) ([]types.RuntimeFramework, error)); ok {
		return rf(ctx, repoType, namespace, name, deployType)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, int) []types.RuntimeFramework); ok {
		r0 = rf(ctx, repoType, namespace, name, deployType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.RuntimeFramework)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, string, int) error); ok {
		r1 = rf(ctx, repoType, namespace, name, deployType)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_ListRuntimeFramework_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuntimeFramework'
type MockRepoComponent_ListRuntimeFramework_Call struct {
	*mock.Call
}

// ListRuntimeFramework is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - deployType int
func (_e *MockRepoComponent_Expecter) ListRuntimeFramework(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, deployType interface{}) *MockRepoComponent_ListRuntimeFramework_Call {
	return &MockRepoComponent_ListRuntimeFramework_Call{Call: _e.mock.On("ListRuntimeFramework", ctx, repoType, namespace, name, deployType)}
}

func (_c *MockRepoComponent_ListRuntimeFramework_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, deployType int)) *MockRepoComponent_ListRuntimeFramework_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(int))
	})
	return _c
}

func (_c *MockRepoComponent_ListRuntimeFramework_Call) Return(_a0 []types.RuntimeFramework, _a1 error) *MockRepoComponent_ListRuntimeFramework_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_ListRuntimeFramework_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, int) ([]types.RuntimeFramework, error)) *MockRepoComponent_ListRuntimeFramework_Call {
	_c.Call.Return(run)
	return _c
}

// ListRuntimeFrameworkWithType provides a mock function with given fields: ctx, deployType
func (_m *MockRepoComponent) ListRuntimeFrameworkWithType(ctx context.Context, deployType int) ([]types.RuntimeFramework, error) {
	ret := _m.Called(ctx, deployType)

	if len(ret) == 0 {
		panic("no return value specified for ListRuntimeFrameworkWithType")
	}

	var r0 []types.RuntimeFramework
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int) ([]types.RuntimeFramework, error)); ok {
		return rf(ctx, deployType)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int) []types.RuntimeFramework); ok {
		r0 = rf(ctx, deployType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.RuntimeFramework)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int) error); ok {
		r1 = rf(ctx, deployType)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_ListRuntimeFrameworkWithType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuntimeFrameworkWithType'
type MockRepoComponent_ListRuntimeFrameworkWithType_Call struct {
	*mock.Call
}

// ListRuntimeFrameworkWithType is a helper method to define mock.On call
//   - ctx context.Context
//   - deployType int
func (_e *MockRepoComponent_Expecter) ListRuntimeFrameworkWithType(ctx interface{}, deployType interface{}) *MockRepoComponent_ListRuntimeFrameworkWithType_Call {
	return &MockRepoComponent_ListRuntimeFrameworkWithType_Call{Call: _e.mock.On("ListRuntimeFrameworkWithType", ctx, deployType)}
}

func (_c *MockRepoComponent_ListRuntimeFrameworkWithType_Call) Run(run func(ctx context.Context, deployType int)) *MockRepoComponent_ListRuntimeFrameworkWithType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int))
	})
	return _c
}

func (_c *MockRepoComponent_ListRuntimeFrameworkWithType_Call) Return(_a0 []types.RuntimeFramework, _a1 error) *MockRepoComponent_ListRuntimeFrameworkWithType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_ListRuntimeFrameworkWithType_Call) RunAndReturn(run func(context.Context, int) ([]types.RuntimeFramework, error)) *MockRepoComponent_ListRuntimeFrameworkWithType_Call {
	_c.Call.Return(run)
	return _c
}

// MirrorFromSaas provides a mock function with given fields: ctx, namespace, name, currentUser, repoType
func (_m *MockRepoComponent) MirrorFromSaas(ctx context.Context, namespace string, name string, currentUser string, repoType types.RepositoryType) error {
	ret := _m.Called(ctx, namespace, name, currentUser, repoType)

	if len(ret) == 0 {
		panic("no return value specified for MirrorFromSaas")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, types.RepositoryType) error); ok {
		r0 = rf(ctx, namespace, name, currentUser, repoType)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_MirrorFromSaas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MirrorFromSaas'
type MockRepoComponent_MirrorFromSaas_Call struct {
	*mock.Call
}

// MirrorFromSaas is a helper method to define mock.On call
//   - ctx context.Context
//   - namespace string
//   - name string
//   - currentUser string
//   - repoType types.RepositoryType
func (_e *MockRepoComponent_Expecter) MirrorFromSaas(ctx interface{}, namespace interface{}, name interface{}, currentUser interface{}, repoType interface{}) *MockRepoComponent_MirrorFromSaas_Call {
	return &MockRepoComponent_MirrorFromSaas_Call{Call: _e.mock.On("MirrorFromSaas", ctx, namespace, name, currentUser, repoType)}
}

func (_c *MockRepoComponent_MirrorFromSaas_Call) Run(run func(ctx context.Context, namespace string, name string, currentUser string, repoType types.RepositoryType)) *MockRepoComponent_MirrorFromSaas_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(types.RepositoryType))
	})
	return _c
}

func (_c *MockRepoComponent_MirrorFromSaas_Call) Return(_a0 error) *MockRepoComponent_MirrorFromSaas_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_MirrorFromSaas_Call) RunAndReturn(run func(context.Context, string, string, string, types.RepositoryType) error) *MockRepoComponent_MirrorFromSaas_Call {
	_c.Call.Return(run)
	return _c
}

// PublicToUser provides a mock function with given fields: ctx, repoType, userName, filter, per, page
func (_m *MockRepoComponent) PublicToUser(ctx context.Context, repoType types.RepositoryType, userName string, filter *types.RepoFilter, per int, page int) ([]*database.Repository, int, error) {
	ret := _m.Called(ctx, repoType, userName, filter, per, page)

	if len(ret) == 0 {
		panic("no return value specified for PublicToUser")
	}

	var r0 []*database.Repository
	var r1 int
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, *types.RepoFilter, int, int) ([]*database.Repository, int, error)); ok {
		return rf(ctx, repoType, userName, filter, per, page)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, *types.RepoFilter, int, int) []*database.Repository); ok {
		r0 = rf(ctx, repoType, userName, filter, per, page)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*database.Repository)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, *types.RepoFilter, int, int) int); ok {
		r1 = rf(ctx, repoType, userName, filter, per, page)
	} else {
		r1 = ret.Get(1).(int)
	}

	if rf, ok := ret.Get(2).(func(context.Context, types.RepositoryType, string, *types.RepoFilter, int, int) error); ok {
		r2 = rf(ctx, repoType, userName, filter, per, page)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// MockRepoComponent_PublicToUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublicToUser'
type MockRepoComponent_PublicToUser_Call struct {
	*mock.Call
}

// PublicToUser is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - userName string
//   - filter *types.RepoFilter
//   - per int
//   - page int
func (_e *MockRepoComponent_Expecter) PublicToUser(ctx interface{}, repoType interface{}, userName interface{}, filter interface{}, per interface{}, page interface{}) *MockRepoComponent_PublicToUser_Call {
	return &MockRepoComponent_PublicToUser_Call{Call: _e.mock.On("PublicToUser", ctx, repoType, userName, filter, per, page)}
}

func (_c *MockRepoComponent_PublicToUser_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, userName string, filter *types.RepoFilter, per int, page int)) *MockRepoComponent_PublicToUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(*types.RepoFilter), args[4].(int), args[5].(int))
	})
	return _c
}

func (_c *MockRepoComponent_PublicToUser_Call) Return(repos []*database.Repository, count int, err error) *MockRepoComponent_PublicToUser_Call {
	_c.Call.Return(repos, count, err)
	return _c
}

func (_c *MockRepoComponent_PublicToUser_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, *types.RepoFilter, int, int) ([]*database.Repository, int, error)) *MockRepoComponent_PublicToUser_Call {
	_c.Call.Return(run)
	return _c
}

// RelatedRepos provides a mock function with given fields: ctx, repoID, currentUser
func (_m *MockRepoComponent) RelatedRepos(ctx context.Context, repoID int64, currentUser string) (map[types.RepositoryType][]*database.Repository, error) {
	ret := _m.Called(ctx, repoID, currentUser)

	if len(ret) == 0 {
		panic("no return value specified for RelatedRepos")
	}

	var r0 map[types.RepositoryType][]*database.Repository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, string) (map[types.RepositoryType][]*database.Repository, error)); ok {
		return rf(ctx, repoID, currentUser)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64, string) map[types.RepositoryType][]*database.Repository); ok {
		r0 = rf(ctx, repoID, currentUser)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[types.RepositoryType][]*database.Repository)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok {
		r1 = rf(ctx, repoID, currentUser)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_RelatedRepos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RelatedRepos'
type MockRepoComponent_RelatedRepos_Call struct {
	*mock.Call
}

// RelatedRepos is a helper method to define mock.On call
//   - ctx context.Context
//   - repoID int64
//   - currentUser string
func (_e *MockRepoComponent_Expecter) RelatedRepos(ctx interface{}, repoID interface{}, currentUser interface{}) *MockRepoComponent_RelatedRepos_Call {
	return &MockRepoComponent_RelatedRepos_Call{Call: _e.mock.On("RelatedRepos", ctx, repoID, currentUser)}
}

func (_c *MockRepoComponent_RelatedRepos_Call) Run(run func(ctx context.Context, repoID int64, currentUser string)) *MockRepoComponent_RelatedRepos_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(string))
	})
	return _c
}

func (_c *MockRepoComponent_RelatedRepos_Call) Return(_a0 map[types.RepositoryType][]*database.Repository, _a1 error) *MockRepoComponent_RelatedRepos_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_RelatedRepos_Call) RunAndReturn(run func(context.Context, int64, string) (map[types.RepositoryType][]*database.Repository, error)) *MockRepoComponent_RelatedRepos_Call {
	_c.Call.Return(run)
	return _c
}

// SDKDownloadFile provides a mock function with given fields: ctx, req, userName
func (_m *MockRepoComponent) SDKDownloadFile(ctx context.Context, req *types.GetFileReq, userName string) (io.ReadCloser, int64, string, error) {
	ret := _m.Called(ctx, req, userName)

	if len(ret) == 0 {
		panic("no return value specified for SDKDownloadFile")
	}

	var r0 io.ReadCloser
	var r1 int64
	var r2 string
	var r3 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq, string) (io.ReadCloser, int64, string, error)); ok {
		return rf(ctx, req, userName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq, string) io.ReadCloser); ok {
		r0 = rf(ctx, req, userName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetFileReq, string) int64); ok {
		r1 = rf(ctx, req, userName)
	} else {
		r1 = ret.Get(1).(int64)
	}

	if rf, ok := ret.Get(2).(func(context.Context, *types.GetFileReq, string) string); ok {
		r2 = rf(ctx, req, userName)
	} else {
		r2 = ret.Get(2).(string)
	}

	if rf, ok := ret.Get(3).(func(context.Context, *types.GetFileReq, string) error); ok {
		r3 = rf(ctx, req, userName)
	} else {
		r3 = ret.Error(3)
	}

	return r0, r1, r2, r3
}

// MockRepoComponent_SDKDownloadFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SDKDownloadFile'
type MockRepoComponent_SDKDownloadFile_Call struct {
	*mock.Call
}

// SDKDownloadFile is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetFileReq
//   - userName string
func (_e *MockRepoComponent_Expecter) SDKDownloadFile(ctx interface{}, req interface{}, userName interface{}) *MockRepoComponent_SDKDownloadFile_Call {
	return &MockRepoComponent_SDKDownloadFile_Call{Call: _e.mock.On("SDKDownloadFile", ctx, req, userName)}
}

func (_c *MockRepoComponent_SDKDownloadFile_Call) Run(run func(ctx context.Context, req *types.GetFileReq, userName string)) *MockRepoComponent_SDKDownloadFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetFileReq), args[2].(string))
	})
	return _c
}

func (_c *MockRepoComponent_SDKDownloadFile_Call) Return(_a0 io.ReadCloser, _a1 int64, _a2 string, _a3 error) *MockRepoComponent_SDKDownloadFile_Call {
	_c.Call.Return(_a0, _a1, _a2, _a3)
	return _c
}

func (_c *MockRepoComponent_SDKDownloadFile_Call) RunAndReturn(run func(context.Context, *types.GetFileReq, string) (io.ReadCloser, int64, string, error)) *MockRepoComponent_SDKDownloadFile_Call {
	_c.Call.Return(run)
	return _c
}

// SDKListFiles provides a mock function with given fields: ctx, repoType, namespace, name, ref, userName
func (_m *MockRepoComponent) SDKListFiles(ctx context.Context, repoType types.RepositoryType, namespace string, name string, ref string, userName string) (*types.SDKFiles, error) {
	ret := _m.Called(ctx, repoType, namespace, name, ref, userName)

	if len(ret) == 0 {
		panic("no return value specified for SDKListFiles")
	}

	var r0 *types.SDKFiles
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string, string) (*types.SDKFiles, error)); ok {
		return rf(ctx, repoType, namespace, name, ref, userName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string, string) *types.SDKFiles); ok {
		r0 = rf(ctx, repoType, namespace, name, ref, userName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.SDKFiles)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.RepositoryType, string, string, string, string) error); ok {
		r1 = rf(ctx, repoType, namespace, name, ref, userName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_SDKListFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SDKListFiles'
type MockRepoComponent_SDKListFiles_Call struct {
	*mock.Call
}

// SDKListFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - ref string
//   - userName string
func (_e *MockRepoComponent_Expecter) SDKListFiles(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, ref interface{}, userName interface{}) *MockRepoComponent_SDKListFiles_Call {
	return &MockRepoComponent_SDKListFiles_Call{Call: _e.mock.On("SDKListFiles", ctx, repoType, namespace, name, ref, userName)}
}

func (_c *MockRepoComponent_SDKListFiles_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, ref string, userName string)) *MockRepoComponent_SDKListFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(string), args[5].(string))
	})
	return _c
}

func (_c *MockRepoComponent_SDKListFiles_Call) Return(_a0 *types.SDKFiles, _a1 error) *MockRepoComponent_SDKListFiles_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_SDKListFiles_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, string, string) (*types.SDKFiles, error)) *MockRepoComponent_SDKListFiles_Call {
	_c.Call.Return(run)
	return _c
}

// SyncMirror provides a mock function with given fields: ctx, repoType, namespace, name, currentUser
func (_m *MockRepoComponent) SyncMirror(ctx context.Context, repoType types.RepositoryType, namespace string, name string, currentUser string) error {
	ret := _m.Called(ctx, repoType, namespace, name, currentUser)

	if len(ret) == 0 {
		panic("no return value specified for SyncMirror")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, types.RepositoryType, string, string, string) error); ok {
		r0 = rf(ctx, repoType, namespace, name, currentUser)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_SyncMirror_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncMirror'
type MockRepoComponent_SyncMirror_Call struct {
	*mock.Call
}

// SyncMirror is a helper method to define mock.On call
//   - ctx context.Context
//   - repoType types.RepositoryType
//   - namespace string
//   - name string
//   - currentUser string
func (_e *MockRepoComponent_Expecter) SyncMirror(ctx interface{}, repoType interface{}, namespace interface{}, name interface{}, currentUser interface{}) *MockRepoComponent_SyncMirror_Call {
	return &MockRepoComponent_SyncMirror_Call{Call: _e.mock.On("SyncMirror", ctx, repoType, namespace, name, currentUser)}
}

func (_c *MockRepoComponent_SyncMirror_Call) Run(run func(ctx context.Context, repoType types.RepositoryType, namespace string, name string, currentUser string)) *MockRepoComponent_SyncMirror_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.RepositoryType), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockRepoComponent_SyncMirror_Call) Return(_a0 error) *MockRepoComponent_SyncMirror_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_SyncMirror_Call) RunAndReturn(run func(context.Context, types.RepositoryType, string, string, string) error) *MockRepoComponent_SyncMirror_Call {
	_c.Call.Return(run)
	return _c
}

// Tags provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) Tags(ctx context.Context, req *types.GetTagsReq) ([]database.Tag, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for Tags")
	}

	var r0 []database.Tag
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetTagsReq) ([]database.Tag, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetTagsReq) []database.Tag); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]database.Tag)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetTagsReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_Tags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Tags'
type MockRepoComponent_Tags_Call struct {
	*mock.Call
}

// Tags is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetTagsReq
func (_e *MockRepoComponent_Expecter) Tags(ctx interface{}, req interface{}) *MockRepoComponent_Tags_Call {
	return &MockRepoComponent_Tags_Call{Call: _e.mock.On("Tags", ctx, req)}
}

func (_c *MockRepoComponent_Tags_Call) Run(run func(ctx context.Context, req *types.GetTagsReq)) *MockRepoComponent_Tags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetTagsReq))
	})
	return _c
}

func (_c *MockRepoComponent_Tags_Call) Return(_a0 []database.Tag, _a1 error) *MockRepoComponent_Tags_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_Tags_Call) RunAndReturn(run func(context.Context, *types.GetTagsReq) ([]database.Tag, error)) *MockRepoComponent_Tags_Call {
	_c.Call.Return(run)
	return _c
}

// Tree provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) Tree(ctx context.Context, req *types.GetFileReq) ([]*types.File, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for Tree")
	}

	var r0 []*types.File
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq) ([]*types.File, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.GetFileReq) []*types.File); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.File)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.GetFileReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_Tree_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Tree'
type MockRepoComponent_Tree_Call struct {
	*mock.Call
}

// Tree is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.GetFileReq
func (_e *MockRepoComponent_Expecter) Tree(ctx interface{}, req interface{}) *MockRepoComponent_Tree_Call {
	return &MockRepoComponent_Tree_Call{Call: _e.mock.On("Tree", ctx, req)}
}

func (_c *MockRepoComponent_Tree_Call) Run(run func(ctx context.Context, req *types.GetFileReq)) *MockRepoComponent_Tree_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.GetFileReq))
	})
	return _c
}

func (_c *MockRepoComponent_Tree_Call) Return(_a0 []*types.File, _a1 error) *MockRepoComponent_Tree_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_Tree_Call) RunAndReturn(run func(context.Context, *types.GetFileReq) ([]*types.File, error)) *MockRepoComponent_Tree_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDownloads provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) UpdateDownloads(ctx context.Context, req *types.UpdateDownloadsReq) error {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for UpdateDownloads")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.UpdateDownloadsReq) error); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_UpdateDownloads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDownloads'
type MockRepoComponent_UpdateDownloads_Call struct {
	*mock.Call
}

// UpdateDownloads is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.UpdateDownloadsReq
func (_e *MockRepoComponent_Expecter) UpdateDownloads(ctx interface{}, req interface{}) *MockRepoComponent_UpdateDownloads_Call {
	return &MockRepoComponent_UpdateDownloads_Call{Call: _e.mock.On("UpdateDownloads", ctx, req)}
}

func (_c *MockRepoComponent_UpdateDownloads_Call) Run(run func(ctx context.Context, req *types.UpdateDownloadsReq)) *MockRepoComponent_UpdateDownloads_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.UpdateDownloadsReq))
	})
	return _c
}

func (_c *MockRepoComponent_UpdateDownloads_Call) Return(_a0 error) *MockRepoComponent_UpdateDownloads_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_UpdateDownloads_Call) RunAndReturn(run func(context.Context, *types.UpdateDownloadsReq) error) *MockRepoComponent_UpdateDownloads_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFile provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) UpdateFile(ctx context.Context, req *types.UpdateFileReq) (*types.UpdateFileResp, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for UpdateFile")
	}

	var r0 *types.UpdateFileResp
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.UpdateFileReq) (*types.UpdateFileResp, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.UpdateFileReq) *types.UpdateFileResp); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.UpdateFileResp)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.UpdateFileReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_UpdateFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFile'
type MockRepoComponent_UpdateFile_Call struct {
	*mock.Call
}

// UpdateFile is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.UpdateFileReq
func (_e *MockRepoComponent_Expecter) UpdateFile(ctx interface{}, req interface{}) *MockRepoComponent_UpdateFile_Call {
	return &MockRepoComponent_UpdateFile_Call{Call: _e.mock.On("UpdateFile", ctx, req)}
}

func (_c *MockRepoComponent_UpdateFile_Call) Run(run func(ctx context.Context, req *types.UpdateFileReq)) *MockRepoComponent_UpdateFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.UpdateFileReq))
	})
	return _c
}

func (_c *MockRepoComponent_UpdateFile_Call) Return(_a0 *types.UpdateFileResp, _a1 error) *MockRepoComponent_UpdateFile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_UpdateFile_Call) RunAndReturn(run func(context.Context, *types.UpdateFileReq) (*types.UpdateFileResp, error)) *MockRepoComponent_UpdateFile_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateMirror provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) UpdateMirror(ctx context.Context, req types.UpdateMirrorReq) (*database.Mirror, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for UpdateMirror")
	}

	var r0 *database.Mirror
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UpdateMirrorReq) (*database.Mirror, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UpdateMirrorReq) *database.Mirror); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.Mirror)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UpdateMirrorReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_UpdateMirror_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMirror'
type MockRepoComponent_UpdateMirror_Call struct {
	*mock.Call
}

// UpdateMirror is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.UpdateMirrorReq
func (_e *MockRepoComponent_Expecter) UpdateMirror(ctx interface{}, req interface{}) *MockRepoComponent_UpdateMirror_Call {
	return &MockRepoComponent_UpdateMirror_Call{Call: _e.mock.On("UpdateMirror", ctx, req)}
}

func (_c *MockRepoComponent_UpdateMirror_Call) Run(run func(ctx context.Context, req types.UpdateMirrorReq)) *MockRepoComponent_UpdateMirror_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.UpdateMirrorReq))
	})
	return _c
}

func (_c *MockRepoComponent_UpdateMirror_Call) Return(_a0 *database.Mirror, _a1 error) *MockRepoComponent_UpdateMirror_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_UpdateMirror_Call) RunAndReturn(run func(context.Context, types.UpdateMirrorReq) (*database.Mirror, error)) *MockRepoComponent_UpdateMirror_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRepo provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) UpdateRepo(ctx context.Context, req types.UpdateRepoReq) (*database.Repository, error) {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRepo")
	}

	var r0 *database.Repository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UpdateRepoReq) (*database.Repository, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UpdateRepoReq) *database.Repository); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*database.Repository)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UpdateRepoReq) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_UpdateRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRepo'
type MockRepoComponent_UpdateRepo_Call struct {
	*mock.Call
}

// UpdateRepo is a helper method to define mock.On call
//   - ctx context.Context
//   - req types.UpdateRepoReq
func (_e *MockRepoComponent_Expecter) UpdateRepo(ctx interface{}, req interface{}) *MockRepoComponent_UpdateRepo_Call {
	return &MockRepoComponent_UpdateRepo_Call{Call: _e.mock.On("UpdateRepo", ctx, req)}
}

func (_c *MockRepoComponent_UpdateRepo_Call) Run(run func(ctx context.Context, req types.UpdateRepoReq)) *MockRepoComponent_UpdateRepo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.UpdateRepoReq))
	})
	return _c
}

func (_c *MockRepoComponent_UpdateRepo_Call) Return(_a0 *database.Repository, _a1 error) *MockRepoComponent_UpdateRepo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_UpdateRepo_Call) RunAndReturn(run func(context.Context, types.UpdateRepoReq) (*database.Repository, error)) *MockRepoComponent_UpdateRepo_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRuntimeFramework provides a mock function with given fields: ctx, id, req
func (_m *MockRepoComponent) UpdateRuntimeFramework(ctx context.Context, id int64, req *types.RuntimeFrameworkReq) (*types.RuntimeFramework, error) {
	ret := _m.Called(ctx, id, req)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRuntimeFramework")
	}

	var r0 *types.RuntimeFramework
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, *types.RuntimeFrameworkReq) (*types.RuntimeFramework, error)); ok {
		return rf(ctx, id, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64, *types.RuntimeFrameworkReq) *types.RuntimeFramework); ok {
		r0 = rf(ctx, id, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.RuntimeFramework)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, int64, *types.RuntimeFrameworkReq) error); ok {
		r1 = rf(ctx, id, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockRepoComponent_UpdateRuntimeFramework_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRuntimeFramework'
type MockRepoComponent_UpdateRuntimeFramework_Call struct {
	*mock.Call
}

// UpdateRuntimeFramework is a helper method to define mock.On call
//   - ctx context.Context
//   - id int64
//   - req *types.RuntimeFrameworkReq
func (_e *MockRepoComponent_Expecter) UpdateRuntimeFramework(ctx interface{}, id interface{}, req interface{}) *MockRepoComponent_UpdateRuntimeFramework_Call {
	return &MockRepoComponent_UpdateRuntimeFramework_Call{Call: _e.mock.On("UpdateRuntimeFramework", ctx, id, req)}
}

func (_c *MockRepoComponent_UpdateRuntimeFramework_Call) Run(run func(ctx context.Context, id int64, req *types.RuntimeFrameworkReq)) *MockRepoComponent_UpdateRuntimeFramework_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(int64), args[2].(*types.RuntimeFrameworkReq))
	})
	return _c
}

func (_c *MockRepoComponent_UpdateRuntimeFramework_Call) Return(_a0 *types.RuntimeFramework, _a1 error) *MockRepoComponent_UpdateRuntimeFramework_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockRepoComponent_UpdateRuntimeFramework_Call) RunAndReturn(run func(context.Context, int64, *types.RuntimeFrameworkReq) (*types.RuntimeFramework, error)) *MockRepoComponent_UpdateRuntimeFramework_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTags provides a mock function with given fields: ctx, namespace, name, repoType, category, currentUser, tags
func (_m *MockRepoComponent) UpdateTags(ctx context.Context, namespace string, name string, repoType types.RepositoryType, category string, currentUser string, tags []string) error {
	ret := _m.Called(ctx, namespace, name, repoType, category, currentUser, tags)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTags")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, types.RepositoryType, string, string, []string) error); ok {
		r0 = rf(ctx, namespace, name, repoType, category, currentUser, tags)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_UpdateTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTags'
type MockRepoComponent_UpdateTags_Call struct {
	*mock.Call
}

// UpdateTags is a helper method to define mock.On call
//   - ctx context.Context
//   - namespace string
//   - name string
//   - repoType types.RepositoryType
//   - category string
//   - currentUser string
//   - tags []string
func (_e *MockRepoComponent_Expecter) UpdateTags(ctx interface{}, namespace interface{}, name interface{}, repoType interface{}, category interface{}, currentUser interface{}, tags interface{}) *MockRepoComponent_UpdateTags_Call {
	return &MockRepoComponent_UpdateTags_Call{Call: _e.mock.On("UpdateTags", ctx, namespace, name, repoType, category, currentUser, tags)}
}

func (_c *MockRepoComponent_UpdateTags_Call) Run(run func(ctx context.Context, namespace string, name string, repoType types.RepositoryType, category string, currentUser string, tags []string)) *MockRepoComponent_UpdateTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(types.RepositoryType), args[4].(string), args[5].(string), args[6].([]string))
	})
	return _c
}

func (_c *MockRepoComponent_UpdateTags_Call) Return(_a0 error) *MockRepoComponent_UpdateTags_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_UpdateTags_Call) RunAndReturn(run func(context.Context, string, string, types.RepositoryType, string, string, []string) error) *MockRepoComponent_UpdateTags_Call {
	_c.Call.Return(run)
	return _c
}

// UploadFile provides a mock function with given fields: ctx, req
func (_m *MockRepoComponent) UploadFile(ctx context.Context, req *types.CreateFileReq) error {
	ret := _m.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for UploadFile")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.CreateFileReq) error); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockRepoComponent_UploadFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadFile'
type MockRepoComponent_UploadFile_Call struct {
	*mock.Call
}

// UploadFile is a helper method to define mock.On call
//   - ctx context.Context
//   - req *types.CreateFileReq
func (_e *MockRepoComponent_Expecter) UploadFile(ctx interface{}, req interface{}) *MockRepoComponent_UploadFile_Call {
	return &MockRepoComponent_UploadFile_Call{Call: _e.mock.On("UploadFile", ctx, req)}
}

func (_c *MockRepoComponent_UploadFile_Call) Run(run func(ctx context.Context, req *types.CreateFileReq)) *MockRepoComponent_UploadFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*types.CreateFileReq))
	})
	return _c
}

func (_c *MockRepoComponent_UploadFile_Call) Return(_a0 error) *MockRepoComponent_UploadFile_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockRepoComponent_UploadFile_Call) RunAndReturn(run func(context.Context, *types.CreateFileReq) error) *MockRepoComponent_UploadFile_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockRepoComponent creates a new instance of MockRepoComponent. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockRepoComponent(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRepoComponent {
	mock := &MockRepoComponent{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
