// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	"github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
	"github.com/argoproj/argo-cd/v3/reposerver/apiclient"
	mock "github.com/stretchr/testify/mock"
	"google.golang.org/grpc"
	"google.golang.org/protobuf/types/known/emptypb"
)

// NewRepoServerServiceClient creates a new instance of RepoServerServiceClient. 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 NewRepoServerServiceClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *RepoServerServiceClient {
	mock := &RepoServerServiceClient{}
	mock.Mock.Test(t)

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

	return mock
}

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

type RepoServerServiceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *RepoServerServiceClient) EXPECT() *RepoServerServiceClient_Expecter {
	return &RepoServerServiceClient_Expecter{mock: &_m.Mock}
}

// GenerateManifest provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GenerateManifest(ctx context.Context, in *apiclient.ManifestRequest, opts ...grpc.CallOption) (*apiclient.ManifestResponse, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.ManifestResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ManifestRequest, ...grpc.CallOption) (*apiclient.ManifestResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ManifestRequest, ...grpc.CallOption) *apiclient.ManifestResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.ManifestResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.ManifestRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GenerateManifest is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.ManifestRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GenerateManifest(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_GenerateManifest_Call {
	return &RepoServerServiceClient_GenerateManifest_Call{Call: _e.mock.On("GenerateManifest",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_GenerateManifest_Call) Run(run func(ctx context.Context, in *apiclient.ManifestRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_GenerateManifest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.ManifestRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.ManifestRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GenerateManifest_Call) Return(manifestResponse *apiclient.ManifestResponse, err error) *RepoServerServiceClient_GenerateManifest_Call {
	_c.Call.Return(manifestResponse, err)
	return _c
}

func (_c *RepoServerServiceClient_GenerateManifest_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.ManifestRequest, opts ...grpc.CallOption) (*apiclient.ManifestResponse, error)) *RepoServerServiceClient_GenerateManifest_Call {
	_c.Call.Return(run)
	return _c
}

// GenerateManifestWithFiles provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GenerateManifestWithFiles(ctx context.Context, opts ...grpc.CallOption) (apiclient.RepoServerService_GenerateManifestWithFilesClient, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 apiclient.RepoServerService_GenerateManifestWithFilesClient
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) (apiclient.RepoServerService_GenerateManifestWithFilesClient, error)); ok {
		return returnFunc(ctx, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) apiclient.RepoServerService_GenerateManifestWithFilesClient); ok {
		r0 = returnFunc(ctx, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(apiclient.RepoServerService_GenerateManifestWithFilesClient)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GenerateManifestWithFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GenerateManifestWithFiles(ctx interface{}, opts ...interface{}) *RepoServerServiceClient_GenerateManifestWithFiles_Call {
	return &RepoServerServiceClient_GenerateManifestWithFiles_Call{Call: _e.mock.On("GenerateManifestWithFiles",
		append([]interface{}{ctx}, opts...)...)}
}

func (_c *RepoServerServiceClient_GenerateManifestWithFiles_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *RepoServerServiceClient_GenerateManifestWithFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GenerateManifestWithFiles_Call) Return(repoServerService_GenerateManifestWithFilesClient apiclient.RepoServerService_GenerateManifestWithFilesClient, err error) *RepoServerServiceClient_GenerateManifestWithFiles_Call {
	_c.Call.Return(repoServerService_GenerateManifestWithFilesClient, err)
	return _c
}

func (_c *RepoServerServiceClient_GenerateManifestWithFiles_Call) RunAndReturn(run func(ctx context.Context, opts ...grpc.CallOption) (apiclient.RepoServerService_GenerateManifestWithFilesClient, error)) *RepoServerServiceClient_GenerateManifestWithFiles_Call {
	_c.Call.Return(run)
	return _c
}

// GetAppDetails provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GetAppDetails(ctx context.Context, in *apiclient.RepoServerAppDetailsQuery, opts ...grpc.CallOption) (*apiclient.RepoAppDetailsResponse, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.RepoAppDetailsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.RepoServerAppDetailsQuery, ...grpc.CallOption) (*apiclient.RepoAppDetailsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.RepoServerAppDetailsQuery, ...grpc.CallOption) *apiclient.RepoAppDetailsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.RepoAppDetailsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.RepoServerAppDetailsQuery, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetAppDetails is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.RepoServerAppDetailsQuery
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GetAppDetails(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_GetAppDetails_Call {
	return &RepoServerServiceClient_GetAppDetails_Call{Call: _e.mock.On("GetAppDetails",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_GetAppDetails_Call) Run(run func(ctx context.Context, in *apiclient.RepoServerAppDetailsQuery, opts ...grpc.CallOption)) *RepoServerServiceClient_GetAppDetails_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.RepoServerAppDetailsQuery
		if args[1] != nil {
			arg1 = args[1].(*apiclient.RepoServerAppDetailsQuery)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GetAppDetails_Call) Return(repoAppDetailsResponse *apiclient.RepoAppDetailsResponse, err error) *RepoServerServiceClient_GetAppDetails_Call {
	_c.Call.Return(repoAppDetailsResponse, err)
	return _c
}

func (_c *RepoServerServiceClient_GetAppDetails_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.RepoServerAppDetailsQuery, opts ...grpc.CallOption) (*apiclient.RepoAppDetailsResponse, error)) *RepoServerServiceClient_GetAppDetails_Call {
	_c.Call.Return(run)
	return _c
}

// GetGitDirectories provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GetGitDirectories(ctx context.Context, in *apiclient.GitDirectoriesRequest, opts ...grpc.CallOption) (*apiclient.GitDirectoriesResponse, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.GitDirectoriesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.GitDirectoriesRequest, ...grpc.CallOption) (*apiclient.GitDirectoriesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.GitDirectoriesRequest, ...grpc.CallOption) *apiclient.GitDirectoriesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.GitDirectoriesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.GitDirectoriesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetGitDirectories is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.GitDirectoriesRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GetGitDirectories(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_GetGitDirectories_Call {
	return &RepoServerServiceClient_GetGitDirectories_Call{Call: _e.mock.On("GetGitDirectories",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_GetGitDirectories_Call) Run(run func(ctx context.Context, in *apiclient.GitDirectoriesRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_GetGitDirectories_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.GitDirectoriesRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.GitDirectoriesRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GetGitDirectories_Call) Return(gitDirectoriesResponse *apiclient.GitDirectoriesResponse, err error) *RepoServerServiceClient_GetGitDirectories_Call {
	_c.Call.Return(gitDirectoriesResponse, err)
	return _c
}

func (_c *RepoServerServiceClient_GetGitDirectories_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.GitDirectoriesRequest, opts ...grpc.CallOption) (*apiclient.GitDirectoriesResponse, error)) *RepoServerServiceClient_GetGitDirectories_Call {
	_c.Call.Return(run)
	return _c
}

// GetGitFiles provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GetGitFiles(ctx context.Context, in *apiclient.GitFilesRequest, opts ...grpc.CallOption) (*apiclient.GitFilesResponse, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.GitFilesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.GitFilesRequest, ...grpc.CallOption) (*apiclient.GitFilesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.GitFilesRequest, ...grpc.CallOption) *apiclient.GitFilesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.GitFilesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.GitFilesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetGitFiles is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.GitFilesRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GetGitFiles(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_GetGitFiles_Call {
	return &RepoServerServiceClient_GetGitFiles_Call{Call: _e.mock.On("GetGitFiles",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_GetGitFiles_Call) Run(run func(ctx context.Context, in *apiclient.GitFilesRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_GetGitFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.GitFilesRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.GitFilesRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GetGitFiles_Call) Return(gitFilesResponse *apiclient.GitFilesResponse, err error) *RepoServerServiceClient_GetGitFiles_Call {
	_c.Call.Return(gitFilesResponse, err)
	return _c
}

func (_c *RepoServerServiceClient_GetGitFiles_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.GitFilesRequest, opts ...grpc.CallOption) (*apiclient.GitFilesResponse, error)) *RepoServerServiceClient_GetGitFiles_Call {
	_c.Call.Return(run)
	return _c
}

// GetHelmCharts provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GetHelmCharts(ctx context.Context, in *apiclient.HelmChartsRequest, opts ...grpc.CallOption) (*apiclient.HelmChartsResponse, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.HelmChartsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.HelmChartsRequest, ...grpc.CallOption) (*apiclient.HelmChartsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.HelmChartsRequest, ...grpc.CallOption) *apiclient.HelmChartsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.HelmChartsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.HelmChartsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetHelmCharts is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.HelmChartsRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GetHelmCharts(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_GetHelmCharts_Call {
	return &RepoServerServiceClient_GetHelmCharts_Call{Call: _e.mock.On("GetHelmCharts",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_GetHelmCharts_Call) Run(run func(ctx context.Context, in *apiclient.HelmChartsRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_GetHelmCharts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.HelmChartsRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.HelmChartsRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GetHelmCharts_Call) Return(helmChartsResponse *apiclient.HelmChartsResponse, err error) *RepoServerServiceClient_GetHelmCharts_Call {
	_c.Call.Return(helmChartsResponse, err)
	return _c
}

func (_c *RepoServerServiceClient_GetHelmCharts_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.HelmChartsRequest, opts ...grpc.CallOption) (*apiclient.HelmChartsResponse, error)) *RepoServerServiceClient_GetHelmCharts_Call {
	_c.Call.Return(run)
	return _c
}

// GetOCIMetadata provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GetOCIMetadata(ctx context.Context, in *apiclient.RepoServerRevisionChartDetailsRequest, opts ...grpc.CallOption) (*v1alpha1.OCIMetadata, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *v1alpha1.OCIMetadata
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.RepoServerRevisionChartDetailsRequest, ...grpc.CallOption) (*v1alpha1.OCIMetadata, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.RepoServerRevisionChartDetailsRequest, ...grpc.CallOption) *v1alpha1.OCIMetadata); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.OCIMetadata)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.RepoServerRevisionChartDetailsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetOCIMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.RepoServerRevisionChartDetailsRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GetOCIMetadata(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_GetOCIMetadata_Call {
	return &RepoServerServiceClient_GetOCIMetadata_Call{Call: _e.mock.On("GetOCIMetadata",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_GetOCIMetadata_Call) Run(run func(ctx context.Context, in *apiclient.RepoServerRevisionChartDetailsRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_GetOCIMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.RepoServerRevisionChartDetailsRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.RepoServerRevisionChartDetailsRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GetOCIMetadata_Call) Return(oCIMetadata *v1alpha1.OCIMetadata, err error) *RepoServerServiceClient_GetOCIMetadata_Call {
	_c.Call.Return(oCIMetadata, err)
	return _c
}

func (_c *RepoServerServiceClient_GetOCIMetadata_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.RepoServerRevisionChartDetailsRequest, opts ...grpc.CallOption) (*v1alpha1.OCIMetadata, error)) *RepoServerServiceClient_GetOCIMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// GetRevisionChartDetails provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GetRevisionChartDetails(ctx context.Context, in *apiclient.RepoServerRevisionChartDetailsRequest, opts ...grpc.CallOption) (*v1alpha1.ChartDetails, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *v1alpha1.ChartDetails
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.RepoServerRevisionChartDetailsRequest, ...grpc.CallOption) (*v1alpha1.ChartDetails, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.RepoServerRevisionChartDetailsRequest, ...grpc.CallOption) *v1alpha1.ChartDetails); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.ChartDetails)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.RepoServerRevisionChartDetailsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRevisionChartDetails is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.RepoServerRevisionChartDetailsRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GetRevisionChartDetails(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_GetRevisionChartDetails_Call {
	return &RepoServerServiceClient_GetRevisionChartDetails_Call{Call: _e.mock.On("GetRevisionChartDetails",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_GetRevisionChartDetails_Call) Run(run func(ctx context.Context, in *apiclient.RepoServerRevisionChartDetailsRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_GetRevisionChartDetails_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.RepoServerRevisionChartDetailsRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.RepoServerRevisionChartDetailsRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GetRevisionChartDetails_Call) Return(chartDetails *v1alpha1.ChartDetails, err error) *RepoServerServiceClient_GetRevisionChartDetails_Call {
	_c.Call.Return(chartDetails, err)
	return _c
}

func (_c *RepoServerServiceClient_GetRevisionChartDetails_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.RepoServerRevisionChartDetailsRequest, opts ...grpc.CallOption) (*v1alpha1.ChartDetails, error)) *RepoServerServiceClient_GetRevisionChartDetails_Call {
	_c.Call.Return(run)
	return _c
}

// GetRevisionMetadata provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) GetRevisionMetadata(ctx context.Context, in *apiclient.RepoServerRevisionMetadataRequest, opts ...grpc.CallOption) (*v1alpha1.RevisionMetadata, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *v1alpha1.RevisionMetadata
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.RepoServerRevisionMetadataRequest, ...grpc.CallOption) (*v1alpha1.RevisionMetadata, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.RepoServerRevisionMetadataRequest, ...grpc.CallOption) *v1alpha1.RevisionMetadata); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.RevisionMetadata)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.RepoServerRevisionMetadataRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRevisionMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.RepoServerRevisionMetadataRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) GetRevisionMetadata(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_GetRevisionMetadata_Call {
	return &RepoServerServiceClient_GetRevisionMetadata_Call{Call: _e.mock.On("GetRevisionMetadata",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_GetRevisionMetadata_Call) Run(run func(ctx context.Context, in *apiclient.RepoServerRevisionMetadataRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_GetRevisionMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.RepoServerRevisionMetadataRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.RepoServerRevisionMetadataRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_GetRevisionMetadata_Call) Return(revisionMetadata *v1alpha1.RevisionMetadata, err error) *RepoServerServiceClient_GetRevisionMetadata_Call {
	_c.Call.Return(revisionMetadata, err)
	return _c
}

func (_c *RepoServerServiceClient_GetRevisionMetadata_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.RepoServerRevisionMetadataRequest, opts ...grpc.CallOption) (*v1alpha1.RevisionMetadata, error)) *RepoServerServiceClient_GetRevisionMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// ListApps provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) ListApps(ctx context.Context, in *apiclient.ListAppsRequest, opts ...grpc.CallOption) (*apiclient.AppList, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.AppList
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ListAppsRequest, ...grpc.CallOption) (*apiclient.AppList, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ListAppsRequest, ...grpc.CallOption) *apiclient.AppList); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.AppList)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.ListAppsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListApps is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.ListAppsRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) ListApps(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_ListApps_Call {
	return &RepoServerServiceClient_ListApps_Call{Call: _e.mock.On("ListApps",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_ListApps_Call) Run(run func(ctx context.Context, in *apiclient.ListAppsRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_ListApps_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.ListAppsRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.ListAppsRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_ListApps_Call) Return(appList *apiclient.AppList, err error) *RepoServerServiceClient_ListApps_Call {
	_c.Call.Return(appList, err)
	return _c
}

func (_c *RepoServerServiceClient_ListApps_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.ListAppsRequest, opts ...grpc.CallOption) (*apiclient.AppList, error)) *RepoServerServiceClient_ListApps_Call {
	_c.Call.Return(run)
	return _c
}

// ListOCITags provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) ListOCITags(ctx context.Context, in *apiclient.ListRefsRequest, opts ...grpc.CallOption) (*apiclient.Refs, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.Refs
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ListRefsRequest, ...grpc.CallOption) (*apiclient.Refs, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ListRefsRequest, ...grpc.CallOption) *apiclient.Refs); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.Refs)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.ListRefsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListOCITags is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.ListRefsRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) ListOCITags(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_ListOCITags_Call {
	return &RepoServerServiceClient_ListOCITags_Call{Call: _e.mock.On("ListOCITags",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_ListOCITags_Call) Run(run func(ctx context.Context, in *apiclient.ListRefsRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_ListOCITags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.ListRefsRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.ListRefsRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_ListOCITags_Call) Return(refs *apiclient.Refs, err error) *RepoServerServiceClient_ListOCITags_Call {
	_c.Call.Return(refs, err)
	return _c
}

func (_c *RepoServerServiceClient_ListOCITags_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.ListRefsRequest, opts ...grpc.CallOption) (*apiclient.Refs, error)) *RepoServerServiceClient_ListOCITags_Call {
	_c.Call.Return(run)
	return _c
}

// ListPlugins provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) ListPlugins(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*apiclient.PluginList, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.PluginList
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*apiclient.PluginList, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *emptypb.Empty, ...grpc.CallOption) *apiclient.PluginList); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.PluginList)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *emptypb.Empty, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListPlugins is a helper method to define mock.On call
//   - ctx context.Context
//   - in *emptypb.Empty
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) ListPlugins(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_ListPlugins_Call {
	return &RepoServerServiceClient_ListPlugins_Call{Call: _e.mock.On("ListPlugins",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_ListPlugins_Call) Run(run func(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption)) *RepoServerServiceClient_ListPlugins_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *emptypb.Empty
		if args[1] != nil {
			arg1 = args[1].(*emptypb.Empty)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_ListPlugins_Call) Return(pluginList *apiclient.PluginList, err error) *RepoServerServiceClient_ListPlugins_Call {
	_c.Call.Return(pluginList, err)
	return _c
}

func (_c *RepoServerServiceClient_ListPlugins_Call) RunAndReturn(run func(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*apiclient.PluginList, error)) *RepoServerServiceClient_ListPlugins_Call {
	_c.Call.Return(run)
	return _c
}

// ListRefs provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) ListRefs(ctx context.Context, in *apiclient.ListRefsRequest, opts ...grpc.CallOption) (*apiclient.Refs, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.Refs
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ListRefsRequest, ...grpc.CallOption) (*apiclient.Refs, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ListRefsRequest, ...grpc.CallOption) *apiclient.Refs); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.Refs)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.ListRefsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListRefs is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.ListRefsRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) ListRefs(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_ListRefs_Call {
	return &RepoServerServiceClient_ListRefs_Call{Call: _e.mock.On("ListRefs",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_ListRefs_Call) Run(run func(ctx context.Context, in *apiclient.ListRefsRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_ListRefs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.ListRefsRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.ListRefsRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_ListRefs_Call) Return(refs *apiclient.Refs, err error) *RepoServerServiceClient_ListRefs_Call {
	_c.Call.Return(refs, err)
	return _c
}

func (_c *RepoServerServiceClient_ListRefs_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.ListRefsRequest, opts ...grpc.CallOption) (*apiclient.Refs, error)) *RepoServerServiceClient_ListRefs_Call {
	_c.Call.Return(run)
	return _c
}

// ResolveRevision provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) ResolveRevision(ctx context.Context, in *apiclient.ResolveRevisionRequest, opts ...grpc.CallOption) (*apiclient.ResolveRevisionResponse, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.ResolveRevisionResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ResolveRevisionRequest, ...grpc.CallOption) (*apiclient.ResolveRevisionResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.ResolveRevisionRequest, ...grpc.CallOption) *apiclient.ResolveRevisionResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.ResolveRevisionResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.ResolveRevisionRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ResolveRevision is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.ResolveRevisionRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) ResolveRevision(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_ResolveRevision_Call {
	return &RepoServerServiceClient_ResolveRevision_Call{Call: _e.mock.On("ResolveRevision",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_ResolveRevision_Call) Run(run func(ctx context.Context, in *apiclient.ResolveRevisionRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_ResolveRevision_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.ResolveRevisionRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.ResolveRevisionRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_ResolveRevision_Call) Return(resolveRevisionResponse *apiclient.ResolveRevisionResponse, err error) *RepoServerServiceClient_ResolveRevision_Call {
	_c.Call.Return(resolveRevisionResponse, err)
	return _c
}

func (_c *RepoServerServiceClient_ResolveRevision_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.ResolveRevisionRequest, opts ...grpc.CallOption) (*apiclient.ResolveRevisionResponse, error)) *RepoServerServiceClient_ResolveRevision_Call {
	_c.Call.Return(run)
	return _c
}

// TestRepository provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) TestRepository(ctx context.Context, in *apiclient.TestRepositoryRequest, opts ...grpc.CallOption) (*apiclient.TestRepositoryResponse, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.TestRepositoryResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.TestRepositoryRequest, ...grpc.CallOption) (*apiclient.TestRepositoryResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.TestRepositoryRequest, ...grpc.CallOption) *apiclient.TestRepositoryResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.TestRepositoryResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.TestRepositoryRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// TestRepository is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.TestRepositoryRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) TestRepository(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_TestRepository_Call {
	return &RepoServerServiceClient_TestRepository_Call{Call: _e.mock.On("TestRepository",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_TestRepository_Call) Run(run func(ctx context.Context, in *apiclient.TestRepositoryRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_TestRepository_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.TestRepositoryRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.TestRepositoryRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_TestRepository_Call) Return(testRepositoryResponse *apiclient.TestRepositoryResponse, err error) *RepoServerServiceClient_TestRepository_Call {
	_c.Call.Return(testRepositoryResponse, err)
	return _c
}

func (_c *RepoServerServiceClient_TestRepository_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.TestRepositoryRequest, opts ...grpc.CallOption) (*apiclient.TestRepositoryResponse, error)) *RepoServerServiceClient_TestRepository_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRevisionForPaths provides a mock function for the type RepoServerServiceClient
func (_mock *RepoServerServiceClient) UpdateRevisionForPaths(ctx context.Context, in *apiclient.UpdateRevisionForPathsRequest, opts ...grpc.CallOption) (*apiclient.UpdateRevisionForPathsResponse, error) {
	// grpc.CallOption
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *apiclient.UpdateRevisionForPathsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.UpdateRevisionForPathsRequest, ...grpc.CallOption) (*apiclient.UpdateRevisionForPathsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *apiclient.UpdateRevisionForPathsRequest, ...grpc.CallOption) *apiclient.UpdateRevisionForPathsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*apiclient.UpdateRevisionForPathsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *apiclient.UpdateRevisionForPathsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateRevisionForPaths is a helper method to define mock.On call
//   - ctx context.Context
//   - in *apiclient.UpdateRevisionForPathsRequest
//   - opts ...grpc.CallOption
func (_e *RepoServerServiceClient_Expecter) UpdateRevisionForPaths(ctx interface{}, in interface{}, opts ...interface{}) *RepoServerServiceClient_UpdateRevisionForPaths_Call {
	return &RepoServerServiceClient_UpdateRevisionForPaths_Call{Call: _e.mock.On("UpdateRevisionForPaths",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *RepoServerServiceClient_UpdateRevisionForPaths_Call) Run(run func(ctx context.Context, in *apiclient.UpdateRevisionForPathsRequest, opts ...grpc.CallOption)) *RepoServerServiceClient_UpdateRevisionForPaths_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *apiclient.UpdateRevisionForPathsRequest
		if args[1] != nil {
			arg1 = args[1].(*apiclient.UpdateRevisionForPathsRequest)
		}
		var arg2 []grpc.CallOption
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *RepoServerServiceClient_UpdateRevisionForPaths_Call) Return(updateRevisionForPathsResponse *apiclient.UpdateRevisionForPathsResponse, err error) *RepoServerServiceClient_UpdateRevisionForPaths_Call {
	_c.Call.Return(updateRevisionForPathsResponse, err)
	return _c
}

func (_c *RepoServerServiceClient_UpdateRevisionForPaths_Call) RunAndReturn(run func(ctx context.Context, in *apiclient.UpdateRevisionForPathsRequest, opts ...grpc.CallOption) (*apiclient.UpdateRevisionForPathsResponse, error)) *RepoServerServiceClient_UpdateRevisionForPaths_Call {
	_c.Call.Return(run)
	return _c
}
