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

package resource

import (
	context "context"

	grpc "google.golang.org/grpc"

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

	resourcepb "github.com/grafana/grafana/pkg/storage/unified/resourcepb"
)

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

type MockResourceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockResourceClient) EXPECT() *MockResourceClient_Expecter {
	return &MockResourceClient_Expecter{mock: &_m.Mock}
}

// BulkProcess provides a mock function with given fields: ctx, opts
func (_m *MockResourceClient) BulkProcess(ctx context.Context, opts ...grpc.CallOption) (resourcepb.BulkStore_BulkProcessClient, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 resourcepb.BulkStore_BulkProcessClient
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) (resourcepb.BulkStore_BulkProcessClient, error)); ok {
		return rf(ctx, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) resourcepb.BulkStore_BulkProcessClient); ok {
		r0 = rf(ctx, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(resourcepb.BulkStore_BulkProcessClient)
		}
	}

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

	return r0, r1
}

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

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

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

func (_c *MockResourceClient_BulkProcess_Call) Return(_a0 resourcepb.BulkStore_BulkProcessClient, _a1 error) *MockResourceClient_BulkProcess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_BulkProcess_Call) RunAndReturn(run func(context.Context, ...grpc.CallOption) (resourcepb.BulkStore_BulkProcessClient, error)) *MockResourceClient_BulkProcess_Call {
	_c.Call.Return(run)
	return _c
}

// CountManagedObjects provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) CountManagedObjects(ctx context.Context, in *resourcepb.CountManagedObjectsRequest, opts ...grpc.CallOption) (*resourcepb.CountManagedObjectsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.CountManagedObjectsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.CountManagedObjectsRequest, ...grpc.CallOption) (*resourcepb.CountManagedObjectsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.CountManagedObjectsRequest, ...grpc.CallOption) *resourcepb.CountManagedObjectsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.CountManagedObjectsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.CountManagedObjectsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CountManagedObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.CountManagedObjectsRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) CountManagedObjects(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_CountManagedObjects_Call {
	return &MockResourceClient_CountManagedObjects_Call{Call: _e.mock.On("CountManagedObjects",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_CountManagedObjects_Call) Return(_a0 *resourcepb.CountManagedObjectsResponse, _a1 error) *MockResourceClient_CountManagedObjects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_CountManagedObjects_Call) RunAndReturn(run func(context.Context, *resourcepb.CountManagedObjectsRequest, ...grpc.CallOption) (*resourcepb.CountManagedObjectsResponse, error)) *MockResourceClient_CountManagedObjects_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) Create(ctx context.Context, in *resourcepb.CreateRequest, opts ...grpc.CallOption) (*resourcepb.CreateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.CreateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.CreateRequest, ...grpc.CallOption) (*resourcepb.CreateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.CreateRequest, ...grpc.CallOption) *resourcepb.CreateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.CreateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.CreateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockResourceClient_Create_Call) Return(_a0 *resourcepb.CreateResponse, _a1 error) *MockResourceClient_Create_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_Create_Call) RunAndReturn(run func(context.Context, *resourcepb.CreateRequest, ...grpc.CallOption) (*resourcepb.CreateResponse, error)) *MockResourceClient_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) Delete(ctx context.Context, in *resourcepb.DeleteRequest, opts ...grpc.CallOption) (*resourcepb.DeleteResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.DeleteResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.DeleteRequest, ...grpc.CallOption) (*resourcepb.DeleteResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.DeleteRequest, ...grpc.CallOption) *resourcepb.DeleteResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.DeleteResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.DeleteRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockResourceClient_Delete_Call) Return(_a0 *resourcepb.DeleteResponse, _a1 error) *MockResourceClient_Delete_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_Delete_Call) RunAndReturn(run func(context.Context, *resourcepb.DeleteRequest, ...grpc.CallOption) (*resourcepb.DeleteResponse, error)) *MockResourceClient_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlob provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) GetBlob(ctx context.Context, in *resourcepb.GetBlobRequest, opts ...grpc.CallOption) (*resourcepb.GetBlobResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.GetBlobResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.GetBlobRequest, ...grpc.CallOption) (*resourcepb.GetBlobResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.GetBlobRequest, ...grpc.CallOption) *resourcepb.GetBlobResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.GetBlobResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.GetBlobRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetBlob is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.GetBlobRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) GetBlob(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_GetBlob_Call {
	return &MockResourceClient_GetBlob_Call{Call: _e.mock.On("GetBlob",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_GetBlob_Call) Return(_a0 *resourcepb.GetBlobResponse, _a1 error) *MockResourceClient_GetBlob_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_GetBlob_Call) RunAndReturn(run func(context.Context, *resourcepb.GetBlobRequest, ...grpc.CallOption) (*resourcepb.GetBlobResponse, error)) *MockResourceClient_GetBlob_Call {
	_c.Call.Return(run)
	return _c
}

// GetQuotaUsage provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) GetQuotaUsage(ctx context.Context, in *resourcepb.QuotaUsageRequest, opts ...grpc.CallOption) (*resourcepb.QuotaUsageResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.QuotaUsageResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.QuotaUsageRequest, ...grpc.CallOption) (*resourcepb.QuotaUsageResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.QuotaUsageRequest, ...grpc.CallOption) *resourcepb.QuotaUsageResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.QuotaUsageResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.QuotaUsageRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetQuotaUsage is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.QuotaUsageRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) GetQuotaUsage(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_GetQuotaUsage_Call {
	return &MockResourceClient_GetQuotaUsage_Call{Call: _e.mock.On("GetQuotaUsage",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_GetQuotaUsage_Call) Return(_a0 *resourcepb.QuotaUsageResponse, _a1 error) *MockResourceClient_GetQuotaUsage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_GetQuotaUsage_Call) RunAndReturn(run func(context.Context, *resourcepb.QuotaUsageRequest, ...grpc.CallOption) (*resourcepb.QuotaUsageResponse, error)) *MockResourceClient_GetQuotaUsage_Call {
	_c.Call.Return(run)
	return _c
}

// GetStats provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) GetStats(ctx context.Context, in *resourcepb.ResourceStatsRequest, opts ...grpc.CallOption) (*resourcepb.ResourceStatsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.ResourceStatsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ResourceStatsRequest, ...grpc.CallOption) (*resourcepb.ResourceStatsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ResourceStatsRequest, ...grpc.CallOption) *resourcepb.ResourceStatsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.ResourceStatsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ResourceStatsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetStats is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.ResourceStatsRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) GetStats(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_GetStats_Call {
	return &MockResourceClient_GetStats_Call{Call: _e.mock.On("GetStats",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_GetStats_Call) Return(_a0 *resourcepb.ResourceStatsResponse, _a1 error) *MockResourceClient_GetStats_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_GetStats_Call) RunAndReturn(run func(context.Context, *resourcepb.ResourceStatsRequest, ...grpc.CallOption) (*resourcepb.ResourceStatsResponse, error)) *MockResourceClient_GetStats_Call {
	_c.Call.Return(run)
	return _c
}

// IsHealthy provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) IsHealthy(ctx context.Context, in *resourcepb.HealthCheckRequest, opts ...grpc.CallOption) (*resourcepb.HealthCheckResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.HealthCheckResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.HealthCheckRequest, ...grpc.CallOption) (*resourcepb.HealthCheckResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.HealthCheckRequest, ...grpc.CallOption) *resourcepb.HealthCheckResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.HealthCheckResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.HealthCheckRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// IsHealthy is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.HealthCheckRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) IsHealthy(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_IsHealthy_Call {
	return &MockResourceClient_IsHealthy_Call{Call: _e.mock.On("IsHealthy",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_IsHealthy_Call) Return(_a0 *resourcepb.HealthCheckResponse, _a1 error) *MockResourceClient_IsHealthy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_IsHealthy_Call) RunAndReturn(run func(context.Context, *resourcepb.HealthCheckRequest, ...grpc.CallOption) (*resourcepb.HealthCheckResponse, error)) *MockResourceClient_IsHealthy_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) List(ctx context.Context, in *resourcepb.ListRequest, opts ...grpc.CallOption) (*resourcepb.ListResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.ListResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ListRequest, ...grpc.CallOption) (*resourcepb.ListResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ListRequest, ...grpc.CallOption) *resourcepb.ListResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.ListResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ListRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockResourceClient_List_Call) Return(_a0 *resourcepb.ListResponse, _a1 error) *MockResourceClient_List_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_List_Call) RunAndReturn(run func(context.Context, *resourcepb.ListRequest, ...grpc.CallOption) (*resourcepb.ListResponse, error)) *MockResourceClient_List_Call {
	_c.Call.Return(run)
	return _c
}

// ListManagedObjects provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) ListManagedObjects(ctx context.Context, in *resourcepb.ListManagedObjectsRequest, opts ...grpc.CallOption) (*resourcepb.ListManagedObjectsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.ListManagedObjectsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ListManagedObjectsRequest, ...grpc.CallOption) (*resourcepb.ListManagedObjectsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ListManagedObjectsRequest, ...grpc.CallOption) *resourcepb.ListManagedObjectsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.ListManagedObjectsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ListManagedObjectsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListManagedObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.ListManagedObjectsRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) ListManagedObjects(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_ListManagedObjects_Call {
	return &MockResourceClient_ListManagedObjects_Call{Call: _e.mock.On("ListManagedObjects",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_ListManagedObjects_Call) Return(_a0 *resourcepb.ListManagedObjectsResponse, _a1 error) *MockResourceClient_ListManagedObjects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_ListManagedObjects_Call) RunAndReturn(run func(context.Context, *resourcepb.ListManagedObjectsRequest, ...grpc.CallOption) (*resourcepb.ListManagedObjectsResponse, error)) *MockResourceClient_ListManagedObjects_Call {
	_c.Call.Return(run)
	return _c
}

// PutBlob provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) PutBlob(ctx context.Context, in *resourcepb.PutBlobRequest, opts ...grpc.CallOption) (*resourcepb.PutBlobResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.PutBlobResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.PutBlobRequest, ...grpc.CallOption) (*resourcepb.PutBlobResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.PutBlobRequest, ...grpc.CallOption) *resourcepb.PutBlobResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.PutBlobResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.PutBlobRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// PutBlob is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.PutBlobRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) PutBlob(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_PutBlob_Call {
	return &MockResourceClient_PutBlob_Call{Call: _e.mock.On("PutBlob",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_PutBlob_Call) Return(_a0 *resourcepb.PutBlobResponse, _a1 error) *MockResourceClient_PutBlob_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_PutBlob_Call) RunAndReturn(run func(context.Context, *resourcepb.PutBlobRequest, ...grpc.CallOption) (*resourcepb.PutBlobResponse, error)) *MockResourceClient_PutBlob_Call {
	_c.Call.Return(run)
	return _c
}

// Read provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) Read(ctx context.Context, in *resourcepb.ReadRequest, opts ...grpc.CallOption) (*resourcepb.ReadResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.ReadResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ReadRequest, ...grpc.CallOption) (*resourcepb.ReadResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ReadRequest, ...grpc.CallOption) *resourcepb.ReadResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.ReadResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ReadRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Read is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.ReadRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) Read(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Read_Call {
	return &MockResourceClient_Read_Call{Call: _e.mock.On("Read",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_Read_Call) Return(_a0 *resourcepb.ReadResponse, _a1 error) *MockResourceClient_Read_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_Read_Call) RunAndReturn(run func(context.Context, *resourcepb.ReadRequest, ...grpc.CallOption) (*resourcepb.ReadResponse, error)) *MockResourceClient_Read_Call {
	_c.Call.Return(run)
	return _c
}

// RebuildIndexes provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) RebuildIndexes(ctx context.Context, in *resourcepb.RebuildIndexesRequest, opts ...grpc.CallOption) (*resourcepb.RebuildIndexesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.RebuildIndexesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.RebuildIndexesRequest, ...grpc.CallOption) (*resourcepb.RebuildIndexesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.RebuildIndexesRequest, ...grpc.CallOption) *resourcepb.RebuildIndexesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.RebuildIndexesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.RebuildIndexesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RebuildIndexes is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.RebuildIndexesRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) RebuildIndexes(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_RebuildIndexes_Call {
	return &MockResourceClient_RebuildIndexes_Call{Call: _e.mock.On("RebuildIndexes",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_RebuildIndexes_Call) Return(_a0 *resourcepb.RebuildIndexesResponse, _a1 error) *MockResourceClient_RebuildIndexes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_RebuildIndexes_Call) RunAndReturn(run func(context.Context, *resourcepb.RebuildIndexesRequest, ...grpc.CallOption) (*resourcepb.RebuildIndexesResponse, error)) *MockResourceClient_RebuildIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// Search provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) Search(ctx context.Context, in *resourcepb.ResourceSearchRequest, opts ...grpc.CallOption) (*resourcepb.ResourceSearchResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.ResourceSearchResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ResourceSearchRequest, ...grpc.CallOption) (*resourcepb.ResourceSearchResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ResourceSearchRequest, ...grpc.CallOption) *resourcepb.ResourceSearchResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.ResourceSearchResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ResourceSearchRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Search is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.ResourceSearchRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) Search(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Search_Call {
	return &MockResourceClient_Search_Call{Call: _e.mock.On("Search",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_Search_Call) Return(_a0 *resourcepb.ResourceSearchResponse, _a1 error) *MockResourceClient_Search_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_Search_Call) RunAndReturn(run func(context.Context, *resourcepb.ResourceSearchRequest, ...grpc.CallOption) (*resourcepb.ResourceSearchResponse, error)) *MockResourceClient_Search_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) Update(ctx context.Context, in *resourcepb.UpdateRequest, opts ...grpc.CallOption) (*resourcepb.UpdateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *resourcepb.UpdateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.UpdateRequest, ...grpc.CallOption) (*resourcepb.UpdateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.UpdateRequest, ...grpc.CallOption) *resourcepb.UpdateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*resourcepb.UpdateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.UpdateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

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

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

func (_c *MockResourceClient_Update_Call) Return(_a0 *resourcepb.UpdateResponse, _a1 error) *MockResourceClient_Update_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_Update_Call) RunAndReturn(run func(context.Context, *resourcepb.UpdateRequest, ...grpc.CallOption) (*resourcepb.UpdateResponse, error)) *MockResourceClient_Update_Call {
	_c.Call.Return(run)
	return _c
}

// Watch provides a mock function with given fields: ctx, in, opts
func (_m *MockResourceClient) Watch(ctx context.Context, in *resourcepb.WatchRequest, opts ...grpc.CallOption) (resourcepb.ResourceStore_WatchClient, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 resourcepb.ResourceStore_WatchClient
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.WatchRequest, ...grpc.CallOption) (resourcepb.ResourceStore_WatchClient, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.WatchRequest, ...grpc.CallOption) resourcepb.ResourceStore_WatchClient); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(resourcepb.ResourceStore_WatchClient)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.WatchRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Watch is a helper method to define mock.On call
//   - ctx context.Context
//   - in *resourcepb.WatchRequest
//   - opts ...grpc.CallOption
func (_e *MockResourceClient_Expecter) Watch(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Watch_Call {
	return &MockResourceClient_Watch_Call{Call: _e.mock.On("Watch",
		append([]interface{}{ctx, in}, opts...)...)}
}

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

func (_c *MockResourceClient_Watch_Call) Return(_a0 resourcepb.ResourceStore_WatchClient, _a1 error) *MockResourceClient_Watch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockResourceClient_Watch_Call) RunAndReturn(run func(context.Context, *resourcepb.WatchRequest, ...grpc.CallOption) (resourcepb.ResourceStore_WatchClient, error)) *MockResourceClient_Watch_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}