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

// NewApplicationServiceClient creates a new instance of ApplicationServiceClient. 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 NewApplicationServiceClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *ApplicationServiceClient {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &ApplicationServiceClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

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

type ApplicationServiceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *ApplicationServiceClient) EXPECT() *ApplicationServiceClient_Expecter {
	return &ApplicationServiceClient_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) Create(ctx context.Context, in *application.ApplicationCreateRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_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.Application
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationCreateRequest, ...grpc.CallOption) (*v1alpha1.Application, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationCreateRequest, ...grpc.CallOption) *v1alpha1.Application); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.Application)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *application.ApplicationCreateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationCreateRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) Create(ctx any, in any, opts ...any) *ApplicationServiceClient_Create_Call {
	return &ApplicationServiceClient_Create_Call{Call: _e.mock.On("Create",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_Create_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationCreateRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error)) *ApplicationServiceClient_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) Delete(ctx context.Context, in *application.ApplicationDeleteRequest, opts ...grpc.CallOption) (*application.ApplicationResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_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 *application.ApplicationResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationDeleteRequest, ...grpc.CallOption) (*application.ApplicationResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationDeleteRequest, ...grpc.CallOption) *application.ApplicationResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*application.ApplicationResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *application.ApplicationDeleteRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationDeleteRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) Delete(ctx any, in any, opts ...any) *ApplicationServiceClient_Delete_Call {
	return &ApplicationServiceClient_Delete_Call{Call: _e.mock.On("Delete",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_Delete_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationDeleteRequest, opts ...grpc.CallOption) (*application.ApplicationResponse, error)) *ApplicationServiceClient_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteResource provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) DeleteResource(ctx context.Context, in *application.ApplicationResourceDeleteRequest, opts ...grpc.CallOption) (*application.ApplicationResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// DeleteResource is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationResourceDeleteRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) DeleteResource(ctx any, in any, opts ...any) *ApplicationServiceClient_DeleteResource_Call {
	return &ApplicationServiceClient_DeleteResource_Call{Call: _e.mock.On("DeleteResource",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_DeleteResource_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationResourceDeleteRequest, opts ...grpc.CallOption) (*application.ApplicationResponse, error)) *ApplicationServiceClient_DeleteResource_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) Get(ctx context.Context, in *application.ApplicationQuery, opts ...grpc.CallOption) (*v1alpha1.Application, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_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.Application
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationQuery, ...grpc.CallOption) (*v1alpha1.Application, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationQuery, ...grpc.CallOption) *v1alpha1.Application); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.Application)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *application.ApplicationQuery, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) Get(ctx any, in any, opts ...any) *ApplicationServiceClient_Get_Call {
	return &ApplicationServiceClient_Get_Call{Call: _e.mock.On("Get",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_Get_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationQuery, opts ...grpc.CallOption) (*v1alpha1.Application, error)) *ApplicationServiceClient_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetApplicationSyncWindows provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) GetApplicationSyncWindows(ctx context.Context, in *application.ApplicationSyncWindowsQuery, opts ...grpc.CallOption) (*application.ApplicationSyncWindowsResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// GetApplicationSyncWindows is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationSyncWindowsQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) GetApplicationSyncWindows(ctx any, in any, opts ...any) *ApplicationServiceClient_GetApplicationSyncWindows_Call {
	return &ApplicationServiceClient_GetApplicationSyncWindows_Call{Call: _e.mock.On("GetApplicationSyncWindows",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_GetApplicationSyncWindows_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationSyncWindowsQuery, opts ...grpc.CallOption) (*application.ApplicationSyncWindowsResponse, error)) *ApplicationServiceClient_GetApplicationSyncWindows_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 *apiclient.ManifestResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationManifestQuery, ...grpc.CallOption) (*apiclient.ManifestResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationManifestQuery, ...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, *application.ApplicationManifestQuery, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetManifests is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationManifestQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) GetManifests(ctx any, in any, opts ...any) *ApplicationServiceClient_GetManifests_Call {
	return &ApplicationServiceClient_GetManifests_Call{Call: _e.mock.On("GetManifests",
		append([]any{ctx, in}, opts...)...)}
}

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

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

// GetManifestsWithFiles provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) GetManifestsWithFiles(ctx context.Context, opts ...grpc.CallOption) (application.ApplicationService_GetManifestsWithFilesClient, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 application.ApplicationService_GetManifestsWithFilesClient
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) (application.ApplicationService_GetManifestsWithFilesClient, error)); ok {
		return returnFunc(ctx, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) application.ApplicationService_GetManifestsWithFilesClient); ok {
		r0 = returnFunc(ctx, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(application.ApplicationService_GetManifestsWithFilesClient)
		}
	}
	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
}

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

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

func (_c *ApplicationServiceClient_GetManifestsWithFiles_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *ApplicationServiceClient_GetManifestsWithFiles_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 *ApplicationServiceClient_GetManifestsWithFiles_Call) Return(applicationService_GetManifestsWithFilesClient application.ApplicationService_GetManifestsWithFilesClient, err error) *ApplicationServiceClient_GetManifestsWithFiles_Call {
	_c.Call.Return(applicationService_GetManifestsWithFilesClient, err)
	return _c
}

func (_c *ApplicationServiceClient_GetManifestsWithFiles_Call) RunAndReturn(run func(ctx context.Context, opts ...grpc.CallOption) (application.ApplicationService_GetManifestsWithFilesClient, error)) *ApplicationServiceClient_GetManifestsWithFiles_Call {
	_c.Call.Return(run)
	return _c
}

// GetOCIMetadata provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) GetOCIMetadata(ctx context.Context, in *application.RevisionMetadataQuery, opts ...grpc.CallOption) (*v1alpha1.OCIMetadata, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_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, *application.RevisionMetadataQuery, ...grpc.CallOption) (*v1alpha1.OCIMetadata, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.RevisionMetadataQuery, ...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, *application.RevisionMetadataQuery, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetOCIMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.RevisionMetadataQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) GetOCIMetadata(ctx any, in any, opts ...any) *ApplicationServiceClient_GetOCIMetadata_Call {
	return &ApplicationServiceClient_GetOCIMetadata_Call{Call: _e.mock.On("GetOCIMetadata",
		append([]any{ctx, in}, opts...)...)}
}

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

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

// GetResource provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) GetResource(ctx context.Context, in *application.ApplicationResourceRequest, opts ...grpc.CallOption) (*application.ApplicationResourceResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// GetResource is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationResourceRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) GetResource(ctx any, in any, opts ...any) *ApplicationServiceClient_GetResource_Call {
	return &ApplicationServiceClient_GetResource_Call{Call: _e.mock.On("GetResource",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_GetResource_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationResourceRequest, opts ...grpc.CallOption) (*application.ApplicationResourceResponse, error)) *ApplicationServiceClient_GetResource_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) List(ctx context.Context, in *application.ApplicationQuery, opts ...grpc.CallOption) (*v1alpha1.ApplicationList, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_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.ApplicationList
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationQuery, ...grpc.CallOption) (*v1alpha1.ApplicationList, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationQuery, ...grpc.CallOption) *v1alpha1.ApplicationList); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.ApplicationList)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *application.ApplicationQuery, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) List(ctx any, in any, opts ...any) *ApplicationServiceClient_List_Call {
	return &ApplicationServiceClient_List_Call{Call: _e.mock.On("List",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_List_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationQuery, opts ...grpc.CallOption) (*v1alpha1.ApplicationList, error)) *ApplicationServiceClient_List_Call {
	_c.Call.Return(run)
	return _c
}

// ListLinks provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) ListLinks(ctx context.Context, in *application.ListAppLinksRequest, opts ...grpc.CallOption) (*application.LinksResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_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, *application.ListAppLinksRequest, ...grpc.CallOption) (*application.LinksResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ListAppLinksRequest, ...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, *application.ListAppLinksRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListLinks is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ListAppLinksRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) ListLinks(ctx any, in any, opts ...any) *ApplicationServiceClient_ListLinks_Call {
	return &ApplicationServiceClient_ListLinks_Call{Call: _e.mock.On("ListLinks",
		append([]any{ctx, in}, opts...)...)}
}

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

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

// ListResourceActions provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) ListResourceActions(ctx context.Context, in *application.ApplicationResourceRequest, opts ...grpc.CallOption) (*application.ResourceActionsListResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// ListResourceActions is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationResourceRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) ListResourceActions(ctx any, in any, opts ...any) *ApplicationServiceClient_ListResourceActions_Call {
	return &ApplicationServiceClient_ListResourceActions_Call{Call: _e.mock.On("ListResourceActions",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_ListResourceActions_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationResourceRequest, opts ...grpc.CallOption) (*application.ResourceActionsListResponse, error)) *ApplicationServiceClient_ListResourceActions_Call {
	_c.Call.Return(run)
	return _c
}

// ListResourceEvents provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) ListResourceEvents(ctx context.Context, in *application.ApplicationResourceEventsQuery, opts ...grpc.CallOption) (*events.EventList, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// ListResourceEvents is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationResourceEventsQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) ListResourceEvents(ctx any, in any, opts ...any) *ApplicationServiceClient_ListResourceEvents_Call {
	return &ApplicationServiceClient_ListResourceEvents_Call{Call: _e.mock.On("ListResourceEvents",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_ListResourceEvents_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationResourceEventsQuery, opts ...grpc.CallOption) (*events.EventList, error)) *ApplicationServiceClient_ListResourceEvents_Call {
	_c.Call.Return(run)
	return _c
}

// ListResourceLinks provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) ListResourceLinks(ctx context.Context, in *application.ApplicationResourceRequest, opts ...grpc.CallOption) (*application.LinksResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 *application.LinksResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationResourceRequest, ...grpc.CallOption) (*application.LinksResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationResourceRequest, ...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, *application.ApplicationResourceRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListResourceLinks is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationResourceRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) ListResourceLinks(ctx any, in any, opts ...any) *ApplicationServiceClient_ListResourceLinks_Call {
	return &ApplicationServiceClient_ListResourceLinks_Call{Call: _e.mock.On("ListResourceLinks",
		append([]any{ctx, in}, opts...)...)}
}

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

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

// ManagedResources provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) ManagedResources(ctx context.Context, in *application.ResourcesQuery, opts ...grpc.CallOption) (*application.ManagedResourcesResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// ManagedResources is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ResourcesQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) ManagedResources(ctx any, in any, opts ...any) *ApplicationServiceClient_ManagedResources_Call {
	return &ApplicationServiceClient_ManagedResources_Call{Call: _e.mock.On("ManagedResources",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_ManagedResources_Call) RunAndReturn(run func(ctx context.Context, in *application.ResourcesQuery, opts ...grpc.CallOption) (*application.ManagedResourcesResponse, error)) *ApplicationServiceClient_ManagedResources_Call {
	_c.Call.Return(run)
	return _c
}

// Patch provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) Patch(ctx context.Context, in *application.ApplicationPatchRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// Patch is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationPatchRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) Patch(ctx any, in any, opts ...any) *ApplicationServiceClient_Patch_Call {
	return &ApplicationServiceClient_Patch_Call{Call: _e.mock.On("Patch",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_Patch_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationPatchRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error)) *ApplicationServiceClient_Patch_Call {
	_c.Call.Return(run)
	return _c
}

// PatchResource provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) PatchResource(ctx context.Context, in *application.ApplicationResourcePatchRequest, opts ...grpc.CallOption) (*application.ApplicationResourceResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// PatchResource is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationResourcePatchRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) PatchResource(ctx any, in any, opts ...any) *ApplicationServiceClient_PatchResource_Call {
	return &ApplicationServiceClient_PatchResource_Call{Call: _e.mock.On("PatchResource",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_PatchResource_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationResourcePatchRequest, opts ...grpc.CallOption) (*application.ApplicationResourceResponse, error)) *ApplicationServiceClient_PatchResource_Call {
	_c.Call.Return(run)
	return _c
}

// PodLogs provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) PodLogs(ctx context.Context, in *application.ApplicationPodLogsQuery, opts ...grpc.CallOption) (application.ApplicationService_PodLogsClient, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// PodLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationPodLogsQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) PodLogs(ctx any, in any, opts ...any) *ApplicationServiceClient_PodLogs_Call {
	return &ApplicationServiceClient_PodLogs_Call{Call: _e.mock.On("PodLogs",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_PodLogs_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationPodLogsQuery, opts ...grpc.CallOption) (application.ApplicationService_PodLogsClient, error)) *ApplicationServiceClient_PodLogs_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceTree provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) ResourceTree(ctx context.Context, in *application.ResourcesQuery, opts ...grpc.CallOption) (*v1alpha1.ApplicationTree, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// ResourceTree is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ResourcesQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) ResourceTree(ctx any, in any, opts ...any) *ApplicationServiceClient_ResourceTree_Call {
	return &ApplicationServiceClient_ResourceTree_Call{Call: _e.mock.On("ResourceTree",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_ResourceTree_Call) RunAndReturn(run func(ctx context.Context, in *application.ResourcesQuery, opts ...grpc.CallOption) (*v1alpha1.ApplicationTree, error)) *ApplicationServiceClient_ResourceTree_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 *v1alpha1.ChartDetails
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.RevisionMetadataQuery, ...grpc.CallOption) (*v1alpha1.ChartDetails, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.RevisionMetadataQuery, ...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, *application.RevisionMetadataQuery, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RevisionChartDetails is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.RevisionMetadataQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) RevisionChartDetails(ctx any, in any, opts ...any) *ApplicationServiceClient_RevisionChartDetails_Call {
	return &ApplicationServiceClient_RevisionChartDetails_Call{Call: _e.mock.On("RevisionChartDetails",
		append([]any{ctx, in}, opts...)...)}
}

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

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

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

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

	var r0 *v1alpha1.RevisionMetadata
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.RevisionMetadataQuery, ...grpc.CallOption) (*v1alpha1.RevisionMetadata, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.RevisionMetadataQuery, ...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, *application.RevisionMetadataQuery, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RevisionMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.RevisionMetadataQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) RevisionMetadata(ctx any, in any, opts ...any) *ApplicationServiceClient_RevisionMetadata_Call {
	return &ApplicationServiceClient_RevisionMetadata_Call{Call: _e.mock.On("RevisionMetadata",
		append([]any{ctx, in}, opts...)...)}
}

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

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

// Rollback provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) Rollback(ctx context.Context, in *application.ApplicationRollbackRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// Rollback is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationRollbackRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) Rollback(ctx any, in any, opts ...any) *ApplicationServiceClient_Rollback_Call {
	return &ApplicationServiceClient_Rollback_Call{Call: _e.mock.On("Rollback",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_Rollback_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationRollbackRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error)) *ApplicationServiceClient_Rollback_Call {
	_c.Call.Return(run)
	return _c
}

// RunResourceAction provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) RunResourceAction(ctx context.Context, in *application.ResourceActionRunRequest, opts ...grpc.CallOption) (*application.ApplicationResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// RunResourceAction is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ResourceActionRunRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) RunResourceAction(ctx any, in any, opts ...any) *ApplicationServiceClient_RunResourceAction_Call {
	return &ApplicationServiceClient_RunResourceAction_Call{Call: _e.mock.On("RunResourceAction",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_RunResourceAction_Call) RunAndReturn(run func(ctx context.Context, in *application.ResourceActionRunRequest, opts ...grpc.CallOption) (*application.ApplicationResponse, error)) *ApplicationServiceClient_RunResourceAction_Call {
	_c.Call.Return(run)
	return _c
}

// RunResourceActionV2 provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) RunResourceActionV2(ctx context.Context, in *application.ResourceActionRunRequestV2, opts ...grpc.CallOption) (*application.ApplicationResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// RunResourceActionV2 is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ResourceActionRunRequestV2
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) RunResourceActionV2(ctx any, in any, opts ...any) *ApplicationServiceClient_RunResourceActionV2_Call {
	return &ApplicationServiceClient_RunResourceActionV2_Call{Call: _e.mock.On("RunResourceActionV2",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_RunResourceActionV2_Call) RunAndReturn(run func(ctx context.Context, in *application.ResourceActionRunRequestV2, opts ...grpc.CallOption) (*application.ApplicationResponse, error)) *ApplicationServiceClient_RunResourceActionV2_Call {
	_c.Call.Return(run)
	return _c
}

// ServerSideDiff provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) ServerSideDiff(ctx context.Context, in *application.ApplicationServerSideDiffQuery, opts ...grpc.CallOption) (*application.ApplicationServerSideDiffResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// ServerSideDiff is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationServerSideDiffQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) ServerSideDiff(ctx any, in any, opts ...any) *ApplicationServiceClient_ServerSideDiff_Call {
	return &ApplicationServiceClient_ServerSideDiff_Call{Call: _e.mock.On("ServerSideDiff",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_ServerSideDiff_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationServerSideDiffQuery, opts ...grpc.CallOption) (*application.ApplicationServerSideDiffResponse, error)) *ApplicationServiceClient_ServerSideDiff_Call {
	_c.Call.Return(run)
	return _c
}

// Sync provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) Sync(ctx context.Context, in *application.ApplicationSyncRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// Sync is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationSyncRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) Sync(ctx any, in any, opts ...any) *ApplicationServiceClient_Sync_Call {
	return &ApplicationServiceClient_Sync_Call{Call: _e.mock.On("Sync",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_Sync_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationSyncRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error)) *ApplicationServiceClient_Sync_Call {
	_c.Call.Return(run)
	return _c
}

// TerminateOperation provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) TerminateOperation(ctx context.Context, in *application.OperationTerminateRequest, opts ...grpc.CallOption) (*application.OperationTerminateResponse, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// TerminateOperation is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.OperationTerminateRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) TerminateOperation(ctx any, in any, opts ...any) *ApplicationServiceClient_TerminateOperation_Call {
	return &ApplicationServiceClient_TerminateOperation_Call{Call: _e.mock.On("TerminateOperation",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_TerminateOperation_Call) RunAndReturn(run func(ctx context.Context, in *application.OperationTerminateRequest, opts ...grpc.CallOption) (*application.OperationTerminateResponse, error)) *ApplicationServiceClient_TerminateOperation_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) Update(ctx context.Context, in *application.ApplicationUpdateRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_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.Application
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationUpdateRequest, ...grpc.CallOption) (*v1alpha1.Application, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *application.ApplicationUpdateRequest, ...grpc.CallOption) *v1alpha1.Application); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1alpha1.Application)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *application.ApplicationUpdateRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Update is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationUpdateRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) Update(ctx any, in any, opts ...any) *ApplicationServiceClient_Update_Call {
	return &ApplicationServiceClient_Update_Call{Call: _e.mock.On("Update",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_Update_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationUpdateRequest, opts ...grpc.CallOption) (*v1alpha1.Application, error)) *ApplicationServiceClient_Update_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSpec provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) UpdateSpec(ctx context.Context, in *application.ApplicationUpdateSpecRequest, opts ...grpc.CallOption) (*v1alpha1.ApplicationSpec, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// UpdateSpec is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationUpdateSpecRequest
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) UpdateSpec(ctx any, in any, opts ...any) *ApplicationServiceClient_UpdateSpec_Call {
	return &ApplicationServiceClient_UpdateSpec_Call{Call: _e.mock.On("UpdateSpec",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_UpdateSpec_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationUpdateSpecRequest, opts ...grpc.CallOption) (*v1alpha1.ApplicationSpec, error)) *ApplicationServiceClient_UpdateSpec_Call {
	_c.Call.Return(run)
	return _c
}

// Watch provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) Watch(ctx context.Context, in *application.ApplicationQuery, opts ...grpc.CallOption) (application.ApplicationService_WatchClient, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// Watch is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ApplicationQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) Watch(ctx any, in any, opts ...any) *ApplicationServiceClient_Watch_Call {
	return &ApplicationServiceClient_Watch_Call{Call: _e.mock.On("Watch",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_Watch_Call) RunAndReturn(run func(ctx context.Context, in *application.ApplicationQuery, opts ...grpc.CallOption) (application.ApplicationService_WatchClient, error)) *ApplicationServiceClient_Watch_Call {
	_c.Call.Return(run)
	return _c
}

// WatchResourceTree provides a mock function for the type ApplicationServiceClient
func (_mock *ApplicationServiceClient) WatchResourceTree(ctx context.Context, in *application.ResourcesQuery, opts ...grpc.CallOption) (application.ApplicationService_WatchResourceTreeClient, error) {
	// grpc.CallOption
	_va := make([]any, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []any
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// WatchResourceTree is a helper method to define mock.On call
//   - ctx context.Context
//   - in *application.ResourcesQuery
//   - opts ...grpc.CallOption
func (_e *ApplicationServiceClient_Expecter) WatchResourceTree(ctx any, in any, opts ...any) *ApplicationServiceClient_WatchResourceTree_Call {
	return &ApplicationServiceClient_WatchResourceTree_Call{Call: _e.mock.On("WatchResourceTree",
		append([]any{ctx, in}, opts...)...)}
}

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

func (_c *ApplicationServiceClient_WatchResourceTree_Call) RunAndReturn(run func(ctx context.Context, in *application.ResourcesQuery, opts ...grpc.CallOption) (application.ApplicationService_WatchResourceTreeClient, error)) *ApplicationServiceClient_WatchResourceTree_Call {
	_c.Call.Return(run)
	return _c
}