github.com/grafana/pyroscope@v1.18.0/pkg/test/mocks/mockquerierv1connect/mock_querier_service_client.go

// Code generated by mockery. DO NOT EDIT.

package mockquerierv1connect

import (
	context "context"

	connect "connectrpc.com/connect"

	googlev1 "github.com/grafana/pyroscope/api/gen/proto/go/google/v1"

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

	querierv1 "github.com/grafana/pyroscope/api/gen/proto/go/querier/v1"

	typesv1 "github.com/grafana/pyroscope/api/gen/proto/go/types/v1"
)

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

type MockQuerierServiceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockQuerierServiceClient) EXPECT() *MockQuerierServiceClient_Expecter {
	return &MockQuerierServiceClient_Expecter{mock: &_m.Mock}
}

// AnalyzeQuery provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) AnalyzeQuery(_a0 context.Context, _a1 *connect.Request[querierv1.AnalyzeQueryRequest]) (*connect.Response[querierv1.AnalyzeQueryResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[querierv1.AnalyzeQueryResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.AnalyzeQueryRequest]) (*connect.Response[querierv1.AnalyzeQueryResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.AnalyzeQueryRequest]) *connect.Response[querierv1.AnalyzeQueryResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[querierv1.AnalyzeQueryResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[querierv1.AnalyzeQueryRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AnalyzeQuery is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[querierv1.AnalyzeQueryRequest]
func (_e *MockQuerierServiceClient_Expecter) AnalyzeQuery(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_AnalyzeQuery_Call {
	return &MockQuerierServiceClient_AnalyzeQuery_Call{Call: _e.mock.On("AnalyzeQuery", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_AnalyzeQuery_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[querierv1.AnalyzeQueryRequest])) *MockQuerierServiceClient_AnalyzeQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[querierv1.AnalyzeQueryRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_AnalyzeQuery_Call) Return(_a0 *connect.Response[querierv1.AnalyzeQueryResponse], _a1 error) *MockQuerierServiceClient_AnalyzeQuery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_AnalyzeQuery_Call) RunAndReturn(run func(context.Context, *connect.Request[querierv1.AnalyzeQueryRequest]) (*connect.Response[querierv1.AnalyzeQueryResponse], error)) *MockQuerierServiceClient_AnalyzeQuery_Call {
	_c.Call.Return(run)
	return _c
}

// Diff provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) Diff(_a0 context.Context, _a1 *connect.Request[querierv1.DiffRequest]) (*connect.Response[querierv1.DiffResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[querierv1.DiffResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.DiffRequest]) (*connect.Response[querierv1.DiffResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.DiffRequest]) *connect.Response[querierv1.DiffResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[querierv1.DiffResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[querierv1.DiffRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Diff is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[querierv1.DiffRequest]
func (_e *MockQuerierServiceClient_Expecter) Diff(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_Diff_Call {
	return &MockQuerierServiceClient_Diff_Call{Call: _e.mock.On("Diff", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_Diff_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[querierv1.DiffRequest])) *MockQuerierServiceClient_Diff_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[querierv1.DiffRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_Diff_Call) Return(_a0 *connect.Response[querierv1.DiffResponse], _a1 error) *MockQuerierServiceClient_Diff_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_Diff_Call) RunAndReturn(run func(context.Context, *connect.Request[querierv1.DiffRequest]) (*connect.Response[querierv1.DiffResponse], error)) *MockQuerierServiceClient_Diff_Call {
	_c.Call.Return(run)
	return _c
}

// GetProfileStats provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) GetProfileStats(_a0 context.Context, _a1 *connect.Request[typesv1.GetProfileStatsRequest]) (*connect.Response[typesv1.GetProfileStatsResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[typesv1.GetProfileStatsResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[typesv1.GetProfileStatsRequest]) (*connect.Response[typesv1.GetProfileStatsResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[typesv1.GetProfileStatsRequest]) *connect.Response[typesv1.GetProfileStatsResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[typesv1.GetProfileStatsResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[typesv1.GetProfileStatsRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetProfileStats is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[typesv1.GetProfileStatsRequest]
func (_e *MockQuerierServiceClient_Expecter) GetProfileStats(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_GetProfileStats_Call {
	return &MockQuerierServiceClient_GetProfileStats_Call{Call: _e.mock.On("GetProfileStats", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_GetProfileStats_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[typesv1.GetProfileStatsRequest])) *MockQuerierServiceClient_GetProfileStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[typesv1.GetProfileStatsRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_GetProfileStats_Call) Return(_a0 *connect.Response[typesv1.GetProfileStatsResponse], _a1 error) *MockQuerierServiceClient_GetProfileStats_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_GetProfileStats_Call) RunAndReturn(run func(context.Context, *connect.Request[typesv1.GetProfileStatsRequest]) (*connect.Response[typesv1.GetProfileStatsResponse], error)) *MockQuerierServiceClient_GetProfileStats_Call {
	_c.Call.Return(run)
	return _c
}

// LabelNames provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) LabelNames(_a0 context.Context, _a1 *connect.Request[typesv1.LabelNamesRequest]) (*connect.Response[typesv1.LabelNamesResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[typesv1.LabelNamesResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[typesv1.LabelNamesRequest]) (*connect.Response[typesv1.LabelNamesResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[typesv1.LabelNamesRequest]) *connect.Response[typesv1.LabelNamesResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[typesv1.LabelNamesResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[typesv1.LabelNamesRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LabelNames is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[typesv1.LabelNamesRequest]
func (_e *MockQuerierServiceClient_Expecter) LabelNames(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_LabelNames_Call {
	return &MockQuerierServiceClient_LabelNames_Call{Call: _e.mock.On("LabelNames", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_LabelNames_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[typesv1.LabelNamesRequest])) *MockQuerierServiceClient_LabelNames_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[typesv1.LabelNamesRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_LabelNames_Call) Return(_a0 *connect.Response[typesv1.LabelNamesResponse], _a1 error) *MockQuerierServiceClient_LabelNames_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_LabelNames_Call) RunAndReturn(run func(context.Context, *connect.Request[typesv1.LabelNamesRequest]) (*connect.Response[typesv1.LabelNamesResponse], error)) *MockQuerierServiceClient_LabelNames_Call {
	_c.Call.Return(run)
	return _c
}

// LabelValues provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) LabelValues(_a0 context.Context, _a1 *connect.Request[typesv1.LabelValuesRequest]) (*connect.Response[typesv1.LabelValuesResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[typesv1.LabelValuesResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[typesv1.LabelValuesRequest]) (*connect.Response[typesv1.LabelValuesResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[typesv1.LabelValuesRequest]) *connect.Response[typesv1.LabelValuesResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[typesv1.LabelValuesResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[typesv1.LabelValuesRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LabelValues is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[typesv1.LabelValuesRequest]
func (_e *MockQuerierServiceClient_Expecter) LabelValues(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_LabelValues_Call {
	return &MockQuerierServiceClient_LabelValues_Call{Call: _e.mock.On("LabelValues", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_LabelValues_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[typesv1.LabelValuesRequest])) *MockQuerierServiceClient_LabelValues_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[typesv1.LabelValuesRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_LabelValues_Call) Return(_a0 *connect.Response[typesv1.LabelValuesResponse], _a1 error) *MockQuerierServiceClient_LabelValues_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_LabelValues_Call) RunAndReturn(run func(context.Context, *connect.Request[typesv1.LabelValuesRequest]) (*connect.Response[typesv1.LabelValuesResponse], error)) *MockQuerierServiceClient_LabelValues_Call {
	_c.Call.Return(run)
	return _c
}

// ProfileTypes provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) ProfileTypes(_a0 context.Context, _a1 *connect.Request[querierv1.ProfileTypesRequest]) (*connect.Response[querierv1.ProfileTypesResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[querierv1.ProfileTypesResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.ProfileTypesRequest]) (*connect.Response[querierv1.ProfileTypesResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.ProfileTypesRequest]) *connect.Response[querierv1.ProfileTypesResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[querierv1.ProfileTypesResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[querierv1.ProfileTypesRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ProfileTypes is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[querierv1.ProfileTypesRequest]
func (_e *MockQuerierServiceClient_Expecter) ProfileTypes(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_ProfileTypes_Call {
	return &MockQuerierServiceClient_ProfileTypes_Call{Call: _e.mock.On("ProfileTypes", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_ProfileTypes_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[querierv1.ProfileTypesRequest])) *MockQuerierServiceClient_ProfileTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[querierv1.ProfileTypesRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_ProfileTypes_Call) Return(_a0 *connect.Response[querierv1.ProfileTypesResponse], _a1 error) *MockQuerierServiceClient_ProfileTypes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_ProfileTypes_Call) RunAndReturn(run func(context.Context, *connect.Request[querierv1.ProfileTypesRequest]) (*connect.Response[querierv1.ProfileTypesResponse], error)) *MockQuerierServiceClient_ProfileTypes_Call {
	_c.Call.Return(run)
	return _c
}

// SelectMergeProfile provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) SelectMergeProfile(_a0 context.Context, _a1 *connect.Request[querierv1.SelectMergeProfileRequest]) (*connect.Response[googlev1.Profile], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[googlev1.Profile]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SelectMergeProfileRequest]) (*connect.Response[googlev1.Profile], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SelectMergeProfileRequest]) *connect.Response[googlev1.Profile]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[googlev1.Profile])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[querierv1.SelectMergeProfileRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectMergeProfile is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[querierv1.SelectMergeProfileRequest]
func (_e *MockQuerierServiceClient_Expecter) SelectMergeProfile(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_SelectMergeProfile_Call {
	return &MockQuerierServiceClient_SelectMergeProfile_Call{Call: _e.mock.On("SelectMergeProfile", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_SelectMergeProfile_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[querierv1.SelectMergeProfileRequest])) *MockQuerierServiceClient_SelectMergeProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[querierv1.SelectMergeProfileRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_SelectMergeProfile_Call) Return(_a0 *connect.Response[googlev1.Profile], _a1 error) *MockQuerierServiceClient_SelectMergeProfile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_SelectMergeProfile_Call) RunAndReturn(run func(context.Context, *connect.Request[querierv1.SelectMergeProfileRequest]) (*connect.Response[googlev1.Profile], error)) *MockQuerierServiceClient_SelectMergeProfile_Call {
	_c.Call.Return(run)
	return _c
}

// SelectMergeSpanProfile provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) SelectMergeSpanProfile(_a0 context.Context, _a1 *connect.Request[querierv1.SelectMergeSpanProfileRequest]) (*connect.Response[querierv1.SelectMergeSpanProfileResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[querierv1.SelectMergeSpanProfileResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SelectMergeSpanProfileRequest]) (*connect.Response[querierv1.SelectMergeSpanProfileResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SelectMergeSpanProfileRequest]) *connect.Response[querierv1.SelectMergeSpanProfileResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[querierv1.SelectMergeSpanProfileResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[querierv1.SelectMergeSpanProfileRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectMergeSpanProfile is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[querierv1.SelectMergeSpanProfileRequest]
func (_e *MockQuerierServiceClient_Expecter) SelectMergeSpanProfile(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_SelectMergeSpanProfile_Call {
	return &MockQuerierServiceClient_SelectMergeSpanProfile_Call{Call: _e.mock.On("SelectMergeSpanProfile", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_SelectMergeSpanProfile_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[querierv1.SelectMergeSpanProfileRequest])) *MockQuerierServiceClient_SelectMergeSpanProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[querierv1.SelectMergeSpanProfileRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_SelectMergeSpanProfile_Call) Return(_a0 *connect.Response[querierv1.SelectMergeSpanProfileResponse], _a1 error) *MockQuerierServiceClient_SelectMergeSpanProfile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_SelectMergeSpanProfile_Call) RunAndReturn(run func(context.Context, *connect.Request[querierv1.SelectMergeSpanProfileRequest]) (*connect.Response[querierv1.SelectMergeSpanProfileResponse], error)) *MockQuerierServiceClient_SelectMergeSpanProfile_Call {
	_c.Call.Return(run)
	return _c
}

// SelectMergeStacktraces provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) SelectMergeStacktraces(_a0 context.Context, _a1 *connect.Request[querierv1.SelectMergeStacktracesRequest]) (*connect.Response[querierv1.SelectMergeStacktracesResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[querierv1.SelectMergeStacktracesResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SelectMergeStacktracesRequest]) (*connect.Response[querierv1.SelectMergeStacktracesResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SelectMergeStacktracesRequest]) *connect.Response[querierv1.SelectMergeStacktracesResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[querierv1.SelectMergeStacktracesResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[querierv1.SelectMergeStacktracesRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectMergeStacktraces is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[querierv1.SelectMergeStacktracesRequest]
func (_e *MockQuerierServiceClient_Expecter) SelectMergeStacktraces(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_SelectMergeStacktraces_Call {
	return &MockQuerierServiceClient_SelectMergeStacktraces_Call{Call: _e.mock.On("SelectMergeStacktraces", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_SelectMergeStacktraces_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[querierv1.SelectMergeStacktracesRequest])) *MockQuerierServiceClient_SelectMergeStacktraces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[querierv1.SelectMergeStacktracesRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_SelectMergeStacktraces_Call) Return(_a0 *connect.Response[querierv1.SelectMergeStacktracesResponse], _a1 error) *MockQuerierServiceClient_SelectMergeStacktraces_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_SelectMergeStacktraces_Call) RunAndReturn(run func(context.Context, *connect.Request[querierv1.SelectMergeStacktracesRequest]) (*connect.Response[querierv1.SelectMergeStacktracesResponse], error)) *MockQuerierServiceClient_SelectMergeStacktraces_Call {
	_c.Call.Return(run)
	return _c
}

// SelectSeries provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) SelectSeries(_a0 context.Context, _a1 *connect.Request[querierv1.SelectSeriesRequest]) (*connect.Response[querierv1.SelectSeriesResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[querierv1.SelectSeriesResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SelectSeriesRequest]) (*connect.Response[querierv1.SelectSeriesResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SelectSeriesRequest]) *connect.Response[querierv1.SelectSeriesResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[querierv1.SelectSeriesResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[querierv1.SelectSeriesRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SelectSeries is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[querierv1.SelectSeriesRequest]
func (_e *MockQuerierServiceClient_Expecter) SelectSeries(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_SelectSeries_Call {
	return &MockQuerierServiceClient_SelectSeries_Call{Call: _e.mock.On("SelectSeries", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_SelectSeries_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[querierv1.SelectSeriesRequest])) *MockQuerierServiceClient_SelectSeries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[querierv1.SelectSeriesRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_SelectSeries_Call) Return(_a0 *connect.Response[querierv1.SelectSeriesResponse], _a1 error) *MockQuerierServiceClient_SelectSeries_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_SelectSeries_Call) RunAndReturn(run func(context.Context, *connect.Request[querierv1.SelectSeriesRequest]) (*connect.Response[querierv1.SelectSeriesResponse], error)) *MockQuerierServiceClient_SelectSeries_Call {
	_c.Call.Return(run)
	return _c
}

// Series provides a mock function with given fields: _a0, _a1
func (_m *MockQuerierServiceClient) Series(_a0 context.Context, _a1 *connect.Request[querierv1.SeriesRequest]) (*connect.Response[querierv1.SeriesResponse], error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 *connect.Response[querierv1.SeriesResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SeriesRequest]) (*connect.Response[querierv1.SeriesResponse], error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *connect.Request[querierv1.SeriesRequest]) *connect.Response[querierv1.SeriesResponse]); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connect.Response[querierv1.SeriesResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *connect.Request[querierv1.SeriesRequest]) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Series is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *connect.Request[querierv1.SeriesRequest]
func (_e *MockQuerierServiceClient_Expecter) Series(_a0 interface{}, _a1 interface{}) *MockQuerierServiceClient_Series_Call {
	return &MockQuerierServiceClient_Series_Call{Call: _e.mock.On("Series", _a0, _a1)}
}

func (_c *MockQuerierServiceClient_Series_Call) Run(run func(_a0 context.Context, _a1 *connect.Request[querierv1.SeriesRequest])) *MockQuerierServiceClient_Series_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*connect.Request[querierv1.SeriesRequest]))
	})
	return _c
}

func (_c *MockQuerierServiceClient_Series_Call) Return(_a0 *connect.Response[querierv1.SeriesResponse], _a1 error) *MockQuerierServiceClient_Series_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockQuerierServiceClient_Series_Call) RunAndReturn(run func(context.Context, *connect.Request[querierv1.SeriesRequest]) (*connect.Response[querierv1.SeriesResponse], error)) *MockQuerierServiceClient_Series_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}