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

package mocks

import (
	"context"

	"github.com/argoproj/argo-cd/v3/pkg/apiclient/application"
	"github.com/argoproj/argo-cd/v3/pkg/apiclient/project"
	"github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
	mock "github.com/stretchr/testify/mock"
	"google.golang.org/grpc"
	"k8s.io/api/core/v1"
)

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

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

	return mock
}

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

type ProjectServiceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *ProjectServiceClient) EXPECT() *ProjectServiceClient_Expecter {
	return &ProjectServiceClient_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) Create(ctx context.Context, in *project.ProjectCreateRequest, opts ...grpc.CallOption) (*v1alpha1.AppProject, 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 Create")
	}

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

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectCreateRequest
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) Create(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_Create_Call {
	return &ProjectServiceClient_Create_Call{Call: _e.mock.On("Create",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_Create_Call) Run(run func(ctx context.Context, in *project.ProjectCreateRequest, opts ...grpc.CallOption)) *ProjectServiceClient_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectCreateRequest
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectCreateRequest)
		}
		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 *ProjectServiceClient_Create_Call) Return(appProject *v1alpha1.AppProject, err error) *ProjectServiceClient_Create_Call {
	_c.Call.Return(appProject, err)
	return _c
}

func (_c *ProjectServiceClient_Create_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectCreateRequest, opts ...grpc.CallOption) (*v1alpha1.AppProject, error)) *ProjectServiceClient_Create_Call {
	_c.Call.Return(run)
	return _c
}

// CreateToken provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) CreateToken(ctx context.Context, in *project.ProjectTokenCreateRequest, opts ...grpc.CallOption) (*project.ProjectTokenResponse, 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 CreateToken")
	}

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

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

// CreateToken is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectTokenCreateRequest
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) CreateToken(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_CreateToken_Call {
	return &ProjectServiceClient_CreateToken_Call{Call: _e.mock.On("CreateToken",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_CreateToken_Call) Run(run func(ctx context.Context, in *project.ProjectTokenCreateRequest, opts ...grpc.CallOption)) *ProjectServiceClient_CreateToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectTokenCreateRequest
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectTokenCreateRequest)
		}
		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 *ProjectServiceClient_CreateToken_Call) Return(projectTokenResponse *project.ProjectTokenResponse, err error) *ProjectServiceClient_CreateToken_Call {
	_c.Call.Return(projectTokenResponse, err)
	return _c
}

func (_c *ProjectServiceClient_CreateToken_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectTokenCreateRequest, opts ...grpc.CallOption) (*project.ProjectTokenResponse, error)) *ProjectServiceClient_CreateToken_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) Delete(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*project.EmptyResponse, 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 Delete")
	}

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

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectQuery
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) Delete(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_Delete_Call {
	return &ProjectServiceClient_Delete_Call{Call: _e.mock.On("Delete",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_Delete_Call) Run(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption)) *ProjectServiceClient_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectQuery
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectQuery)
		}
		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 *ProjectServiceClient_Delete_Call) Return(emptyResponse *project.EmptyResponse, err error) *ProjectServiceClient_Delete_Call {
	_c.Call.Return(emptyResponse, err)
	return _c
}

func (_c *ProjectServiceClient_Delete_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*project.EmptyResponse, error)) *ProjectServiceClient_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteToken provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) DeleteToken(ctx context.Context, in *project.ProjectTokenDeleteRequest, opts ...grpc.CallOption) (*project.EmptyResponse, 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 DeleteToken")
	}

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

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

// DeleteToken is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectTokenDeleteRequest
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) DeleteToken(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_DeleteToken_Call {
	return &ProjectServiceClient_DeleteToken_Call{Call: _e.mock.On("DeleteToken",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_DeleteToken_Call) Run(run func(ctx context.Context, in *project.ProjectTokenDeleteRequest, opts ...grpc.CallOption)) *ProjectServiceClient_DeleteToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectTokenDeleteRequest
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectTokenDeleteRequest)
		}
		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 *ProjectServiceClient_DeleteToken_Call) Return(emptyResponse *project.EmptyResponse, err error) *ProjectServiceClient_DeleteToken_Call {
	_c.Call.Return(emptyResponse, err)
	return _c
}

func (_c *ProjectServiceClient_DeleteToken_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectTokenDeleteRequest, opts ...grpc.CallOption) (*project.EmptyResponse, error)) *ProjectServiceClient_DeleteToken_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) Get(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*v1alpha1.AppProject, 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 Get")
	}

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

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectQuery
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) Get(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_Get_Call {
	return &ProjectServiceClient_Get_Call{Call: _e.mock.On("Get",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_Get_Call) Run(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption)) *ProjectServiceClient_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectQuery
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectQuery)
		}
		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 *ProjectServiceClient_Get_Call) Return(appProject *v1alpha1.AppProject, err error) *ProjectServiceClient_Get_Call {
	_c.Call.Return(appProject, err)
	return _c
}

func (_c *ProjectServiceClient_Get_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*v1alpha1.AppProject, error)) *ProjectServiceClient_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetDetailedProject provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) GetDetailedProject(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*project.DetailedProjectsResponse, 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 GetDetailedProject")
	}

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

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

// GetDetailedProject is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectQuery
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) GetDetailedProject(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_GetDetailedProject_Call {
	return &ProjectServiceClient_GetDetailedProject_Call{Call: _e.mock.On("GetDetailedProject",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_GetDetailedProject_Call) Run(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption)) *ProjectServiceClient_GetDetailedProject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectQuery
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectQuery)
		}
		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 *ProjectServiceClient_GetDetailedProject_Call) Return(detailedProjectsResponse *project.DetailedProjectsResponse, err error) *ProjectServiceClient_GetDetailedProject_Call {
	_c.Call.Return(detailedProjectsResponse, err)
	return _c
}

func (_c *ProjectServiceClient_GetDetailedProject_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*project.DetailedProjectsResponse, error)) *ProjectServiceClient_GetDetailedProject_Call {
	_c.Call.Return(run)
	return _c
}

// GetGlobalProjects provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) GetGlobalProjects(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*project.GlobalProjectsResponse, 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 GetGlobalProjects")
	}

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

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

// GetGlobalProjects is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectQuery
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) GetGlobalProjects(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_GetGlobalProjects_Call {
	return &ProjectServiceClient_GetGlobalProjects_Call{Call: _e.mock.On("GetGlobalProjects",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_GetGlobalProjects_Call) Run(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption)) *ProjectServiceClient_GetGlobalProjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectQuery
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectQuery)
		}
		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 *ProjectServiceClient_GetGlobalProjects_Call) Return(globalProjectsResponse *project.GlobalProjectsResponse, err error) *ProjectServiceClient_GetGlobalProjects_Call {
	_c.Call.Return(globalProjectsResponse, err)
	return _c
}

func (_c *ProjectServiceClient_GetGlobalProjects_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*project.GlobalProjectsResponse, error)) *ProjectServiceClient_GetGlobalProjects_Call {
	_c.Call.Return(run)
	return _c
}

// GetSyncWindowsState provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) GetSyncWindowsState(ctx context.Context, in *project.SyncWindowsQuery, opts ...grpc.CallOption) (*project.SyncWindowsResponse, 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 GetSyncWindowsState")
	}

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

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

// GetSyncWindowsState is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.SyncWindowsQuery
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) GetSyncWindowsState(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_GetSyncWindowsState_Call {
	return &ProjectServiceClient_GetSyncWindowsState_Call{Call: _e.mock.On("GetSyncWindowsState",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_GetSyncWindowsState_Call) Run(run func(ctx context.Context, in *project.SyncWindowsQuery, opts ...grpc.CallOption)) *ProjectServiceClient_GetSyncWindowsState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.SyncWindowsQuery
		if args[1] != nil {
			arg1 = args[1].(*project.SyncWindowsQuery)
		}
		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 *ProjectServiceClient_GetSyncWindowsState_Call) Return(syncWindowsResponse *project.SyncWindowsResponse, err error) *ProjectServiceClient_GetSyncWindowsState_Call {
	_c.Call.Return(syncWindowsResponse, err)
	return _c
}

func (_c *ProjectServiceClient_GetSyncWindowsState_Call) RunAndReturn(run func(ctx context.Context, in *project.SyncWindowsQuery, opts ...grpc.CallOption) (*project.SyncWindowsResponse, error)) *ProjectServiceClient_GetSyncWindowsState_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) List(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*v1alpha1.AppProjectList, 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 List")
	}

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

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectQuery
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) List(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_List_Call {
	return &ProjectServiceClient_List_Call{Call: _e.mock.On("List",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_List_Call) Run(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption)) *ProjectServiceClient_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectQuery
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectQuery)
		}
		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 *ProjectServiceClient_List_Call) Return(appProjectList *v1alpha1.AppProjectList, err error) *ProjectServiceClient_List_Call {
	_c.Call.Return(appProjectList, err)
	return _c
}

func (_c *ProjectServiceClient_List_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*v1alpha1.AppProjectList, error)) *ProjectServiceClient_List_Call {
	_c.Call.Return(run)
	return _c
}

// ListEvents provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) ListEvents(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*v1.EventList, 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 ListEvents")
	}

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

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

// ListEvents is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectQuery
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) ListEvents(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_ListEvents_Call {
	return &ProjectServiceClient_ListEvents_Call{Call: _e.mock.On("ListEvents",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_ListEvents_Call) Run(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption)) *ProjectServiceClient_ListEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectQuery
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectQuery)
		}
		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 *ProjectServiceClient_ListEvents_Call) Return(eventList *v1.EventList, err error) *ProjectServiceClient_ListEvents_Call {
	_c.Call.Return(eventList, err)
	return _c
}

func (_c *ProjectServiceClient_ListEvents_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectQuery, opts ...grpc.CallOption) (*v1.EventList, error)) *ProjectServiceClient_ListEvents_Call {
	_c.Call.Return(run)
	return _c
}

// ListLinks provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) ListLinks(ctx context.Context, in *project.ListProjectLinksRequest, opts ...grpc.CallOption) (*application.LinksResponse, 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 ListLinks")
	}

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

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

// ListLinks is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ListProjectLinksRequest
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) ListLinks(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_ListLinks_Call {
	return &ProjectServiceClient_ListLinks_Call{Call: _e.mock.On("ListLinks",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_ListLinks_Call) Run(run func(ctx context.Context, in *project.ListProjectLinksRequest, opts ...grpc.CallOption)) *ProjectServiceClient_ListLinks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ListProjectLinksRequest
		if args[1] != nil {
			arg1 = args[1].(*project.ListProjectLinksRequest)
		}
		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 *ProjectServiceClient_ListLinks_Call) Return(linksResponse *application.LinksResponse, err error) *ProjectServiceClient_ListLinks_Call {
	_c.Call.Return(linksResponse, err)
	return _c
}

func (_c *ProjectServiceClient_ListLinks_Call) RunAndReturn(run func(ctx context.Context, in *project.ListProjectLinksRequest, opts ...grpc.CallOption) (*application.LinksResponse, error)) *ProjectServiceClient_ListLinks_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function for the type ProjectServiceClient
func (_mock *ProjectServiceClient) Update(ctx context.Context, in *project.ProjectUpdateRequest, opts ...grpc.CallOption) (*v1alpha1.AppProject, 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 Update")
	}

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

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

// Update is a helper method to define mock.On call
//   - ctx context.Context
//   - in *project.ProjectUpdateRequest
//   - opts ...grpc.CallOption
func (_e *ProjectServiceClient_Expecter) Update(ctx interface{}, in interface{}, opts ...interface{}) *ProjectServiceClient_Update_Call {
	return &ProjectServiceClient_Update_Call{Call: _e.mock.On("Update",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *ProjectServiceClient_Update_Call) Run(run func(ctx context.Context, in *project.ProjectUpdateRequest, opts ...grpc.CallOption)) *ProjectServiceClient_Update_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *project.ProjectUpdateRequest
		if args[1] != nil {
			arg1 = args[1].(*project.ProjectUpdateRequest)
		}
		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 *ProjectServiceClient_Update_Call) Return(appProject *v1alpha1.AppProject, err error) *ProjectServiceClient_Update_Call {
	_c.Call.Return(appProject, err)
	return _c
}

func (_c *ProjectServiceClient_Update_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectUpdateRequest, opts ...grpc.CallOption) (*v1alpha1.AppProject, error)) *ProjectServiceClient_Update_Call {
	_c.Call.Return(run)
	return _c
}
