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

package referees

import (
	"bytes"
	"context"
	"time"

	"github.com/prometheus/client_golang/api/prometheus/v1"
	"github.com/prometheus/common/model"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

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

type MockMetricsExecutor_Expecter struct {
	mock *mock.Mock
}

func (_m *MockMetricsExecutor) EXPECT() *MockMetricsExecutor_Expecter {
	return &MockMetricsExecutor_Expecter{mock: &_m.Mock}
}

// GetMetricsSelector provides a mock function for the type MockMetricsExecutor
func (_mock *MockMetricsExecutor) GetMetricsSelector() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// GetMetricsSelector is a helper method to define mock.On call
func (_e *MockMetricsExecutor_Expecter) GetMetricsSelector() *MockMetricsExecutor_GetMetricsSelector_Call {
	return &MockMetricsExecutor_GetMetricsSelector_Call{Call: _e.mock.On("GetMetricsSelector")}
}

func (_c *MockMetricsExecutor_GetMetricsSelector_Call) Run(run func()) *MockMetricsExecutor_GetMetricsSelector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockMetricsExecutor_GetMetricsSelector_Call) Return(s string) *MockMetricsExecutor_GetMetricsSelector_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockMetricsExecutor_GetMetricsSelector_Call) RunAndReturn(run func() string) *MockMetricsExecutor_GetMetricsSelector_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type mockPrometheusAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *mockPrometheusAPI) EXPECT() *mockPrometheusAPI_Expecter {
	return &mockPrometheusAPI_Expecter{mock: &_m.Mock}
}

// AlertManagers provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) AlertManagers(ctx context.Context) (v1.AlertManagersResult, error) {
	ret := _mock.Called(ctx)

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

	var r0 v1.AlertManagersResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (v1.AlertManagersResult, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) v1.AlertManagersResult); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(v1.AlertManagersResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AlertManagers is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) AlertManagers(ctx interface{}) *mockPrometheusAPI_AlertManagers_Call {
	return &mockPrometheusAPI_AlertManagers_Call{Call: _e.mock.On("AlertManagers", ctx)}
}

func (_c *mockPrometheusAPI_AlertManagers_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_AlertManagers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_AlertManagers_Call) Return(alertManagersResult v1.AlertManagersResult, err error) *mockPrometheusAPI_AlertManagers_Call {
	_c.Call.Return(alertManagersResult, err)
	return _c
}

func (_c *mockPrometheusAPI_AlertManagers_Call) RunAndReturn(run func(ctx context.Context) (v1.AlertManagersResult, error)) *mockPrometheusAPI_AlertManagers_Call {
	_c.Call.Return(run)
	return _c
}

// Alerts provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Alerts(ctx context.Context) (v1.AlertsResult, error) {
	ret := _mock.Called(ctx)

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

	var r0 v1.AlertsResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (v1.AlertsResult, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) v1.AlertsResult); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(v1.AlertsResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Alerts is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) Alerts(ctx interface{}) *mockPrometheusAPI_Alerts_Call {
	return &mockPrometheusAPI_Alerts_Call{Call: _e.mock.On("Alerts", ctx)}
}

func (_c *mockPrometheusAPI_Alerts_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_Alerts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Alerts_Call) Return(alertsResult v1.AlertsResult, err error) *mockPrometheusAPI_Alerts_Call {
	_c.Call.Return(alertsResult, err)
	return _c
}

func (_c *mockPrometheusAPI_Alerts_Call) RunAndReturn(run func(ctx context.Context) (v1.AlertsResult, error)) *mockPrometheusAPI_Alerts_Call {
	_c.Call.Return(run)
	return _c
}

// Buildinfo provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Buildinfo(ctx context.Context) (v1.BuildinfoResult, error) {
	ret := _mock.Called(ctx)

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

	var r0 v1.BuildinfoResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (v1.BuildinfoResult, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) v1.BuildinfoResult); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(v1.BuildinfoResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Buildinfo is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) Buildinfo(ctx interface{}) *mockPrometheusAPI_Buildinfo_Call {
	return &mockPrometheusAPI_Buildinfo_Call{Call: _e.mock.On("Buildinfo", ctx)}
}

func (_c *mockPrometheusAPI_Buildinfo_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_Buildinfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Buildinfo_Call) Return(buildinfoResult v1.BuildinfoResult, err error) *mockPrometheusAPI_Buildinfo_Call {
	_c.Call.Return(buildinfoResult, err)
	return _c
}

func (_c *mockPrometheusAPI_Buildinfo_Call) RunAndReturn(run func(ctx context.Context) (v1.BuildinfoResult, error)) *mockPrometheusAPI_Buildinfo_Call {
	_c.Call.Return(run)
	return _c
}

// CleanTombstones provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) CleanTombstones(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CleanTombstones is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) CleanTombstones(ctx interface{}) *mockPrometheusAPI_CleanTombstones_Call {
	return &mockPrometheusAPI_CleanTombstones_Call{Call: _e.mock.On("CleanTombstones", ctx)}
}

func (_c *mockPrometheusAPI_CleanTombstones_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_CleanTombstones_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_CleanTombstones_Call) Return(err error) *mockPrometheusAPI_CleanTombstones_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockPrometheusAPI_CleanTombstones_Call) RunAndReturn(run func(ctx context.Context) error) *mockPrometheusAPI_CleanTombstones_Call {
	_c.Call.Return(run)
	return _c
}

// Config provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Config(ctx context.Context) (v1.ConfigResult, error) {
	ret := _mock.Called(ctx)

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

	var r0 v1.ConfigResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (v1.ConfigResult, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) v1.ConfigResult); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(v1.ConfigResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Config is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) Config(ctx interface{}) *mockPrometheusAPI_Config_Call {
	return &mockPrometheusAPI_Config_Call{Call: _e.mock.On("Config", ctx)}
}

func (_c *mockPrometheusAPI_Config_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_Config_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Config_Call) Return(configResult v1.ConfigResult, err error) *mockPrometheusAPI_Config_Call {
	_c.Call.Return(configResult, err)
	return _c
}

func (_c *mockPrometheusAPI_Config_Call) RunAndReturn(run func(ctx context.Context) (v1.ConfigResult, error)) *mockPrometheusAPI_Config_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSeries provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) DeleteSeries(ctx context.Context, matches []string, startTime time.Time, endTime time.Time) error {
	ret := _mock.Called(ctx, matches, startTime, endTime)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, time.Time, time.Time) error); ok {
		r0 = returnFunc(ctx, matches, startTime, endTime)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteSeries is a helper method to define mock.On call
//   - ctx context.Context
//   - matches []string
//   - startTime time.Time
//   - endTime time.Time
func (_e *mockPrometheusAPI_Expecter) DeleteSeries(ctx interface{}, matches interface{}, startTime interface{}, endTime interface{}) *mockPrometheusAPI_DeleteSeries_Call {
	return &mockPrometheusAPI_DeleteSeries_Call{Call: _e.mock.On("DeleteSeries", ctx, matches, startTime, endTime)}
}

func (_c *mockPrometheusAPI_DeleteSeries_Call) Run(run func(ctx context.Context, matches []string, startTime time.Time, endTime time.Time)) *mockPrometheusAPI_DeleteSeries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		var arg3 time.Time
		if args[3] != nil {
			arg3 = args[3].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_DeleteSeries_Call) Return(err error) *mockPrometheusAPI_DeleteSeries_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockPrometheusAPI_DeleteSeries_Call) RunAndReturn(run func(ctx context.Context, matches []string, startTime time.Time, endTime time.Time) error) *mockPrometheusAPI_DeleteSeries_Call {
	_c.Call.Return(run)
	return _c
}

// Flags provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Flags(ctx context.Context) (v1.FlagsResult, error) {
	ret := _mock.Called(ctx)

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

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

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

// Flags is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) Flags(ctx interface{}) *mockPrometheusAPI_Flags_Call {
	return &mockPrometheusAPI_Flags_Call{Call: _e.mock.On("Flags", ctx)}
}

func (_c *mockPrometheusAPI_Flags_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_Flags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Flags_Call) Return(flagsResult v1.FlagsResult, err error) *mockPrometheusAPI_Flags_Call {
	_c.Call.Return(flagsResult, err)
	return _c
}

func (_c *mockPrometheusAPI_Flags_Call) RunAndReturn(run func(ctx context.Context) (v1.FlagsResult, error)) *mockPrometheusAPI_Flags_Call {
	_c.Call.Return(run)
	return _c
}

// LabelNames provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) LabelNames(ctx context.Context, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) ([]string, v1.Warnings, error) {
	// v1.Option
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, matches, startTime, endTime)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 []string
	var r1 v1.Warnings
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) ([]string, v1.Warnings, error)); ok {
		return returnFunc(ctx, matches, startTime, endTime, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) []string); ok {
		r0 = returnFunc(ctx, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) v1.Warnings); ok {
		r1 = returnFunc(ctx, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) error); ok {
		r2 = returnFunc(ctx, matches, startTime, endTime, opts...)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// LabelNames is a helper method to define mock.On call
//   - ctx context.Context
//   - matches []string
//   - startTime time.Time
//   - endTime time.Time
//   - opts ...v1.Option
func (_e *mockPrometheusAPI_Expecter) LabelNames(ctx interface{}, matches interface{}, startTime interface{}, endTime interface{}, opts ...interface{}) *mockPrometheusAPI_LabelNames_Call {
	return &mockPrometheusAPI_LabelNames_Call{Call: _e.mock.On("LabelNames",
		append([]interface{}{ctx, matches, startTime, endTime}, opts...)...)}
}

func (_c *mockPrometheusAPI_LabelNames_Call) Run(run func(ctx context.Context, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option)) *mockPrometheusAPI_LabelNames_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		var arg3 time.Time
		if args[3] != nil {
			arg3 = args[3].(time.Time)
		}
		var arg4 []v1.Option
		variadicArgs := make([]v1.Option, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		arg4 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4...,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_LabelNames_Call) Return(strings []string, warnings v1.Warnings, err error) *mockPrometheusAPI_LabelNames_Call {
	_c.Call.Return(strings, warnings, err)
	return _c
}

func (_c *mockPrometheusAPI_LabelNames_Call) RunAndReturn(run func(ctx context.Context, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) ([]string, v1.Warnings, error)) *mockPrometheusAPI_LabelNames_Call {
	_c.Call.Return(run)
	return _c
}

// LabelValues provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) LabelValues(ctx context.Context, label string, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) (model.LabelValues, v1.Warnings, error) {
	// v1.Option
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, label, matches, startTime, endTime)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 model.LabelValues
	var r1 v1.Warnings
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, time.Time, time.Time, ...v1.Option) (model.LabelValues, v1.Warnings, error)); ok {
		return returnFunc(ctx, label, matches, startTime, endTime, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, time.Time, time.Time, ...v1.Option) model.LabelValues); ok {
		r0 = returnFunc(ctx, label, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.LabelValues)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, []string, time.Time, time.Time, ...v1.Option) v1.Warnings); ok {
		r1 = returnFunc(ctx, label, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, []string, time.Time, time.Time, ...v1.Option) error); ok {
		r2 = returnFunc(ctx, label, matches, startTime, endTime, opts...)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// LabelValues is a helper method to define mock.On call
//   - ctx context.Context
//   - label string
//   - matches []string
//   - startTime time.Time
//   - endTime time.Time
//   - opts ...v1.Option
func (_e *mockPrometheusAPI_Expecter) LabelValues(ctx interface{}, label interface{}, matches interface{}, startTime interface{}, endTime interface{}, opts ...interface{}) *mockPrometheusAPI_LabelValues_Call {
	return &mockPrometheusAPI_LabelValues_Call{Call: _e.mock.On("LabelValues",
		append([]interface{}{ctx, label, matches, startTime, endTime}, opts...)...)}
}

func (_c *mockPrometheusAPI_LabelValues_Call) Run(run func(ctx context.Context, label string, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option)) *mockPrometheusAPI_LabelValues_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		var arg3 time.Time
		if args[3] != nil {
			arg3 = args[3].(time.Time)
		}
		var arg4 time.Time
		if args[4] != nil {
			arg4 = args[4].(time.Time)
		}
		var arg5 []v1.Option
		variadicArgs := make([]v1.Option, len(args)-5)
		for i, a := range args[5:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		arg5 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5...,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_LabelValues_Call) Return(labelValues model.LabelValues, warnings v1.Warnings, err error) *mockPrometheusAPI_LabelValues_Call {
	_c.Call.Return(labelValues, warnings, err)
	return _c
}

func (_c *mockPrometheusAPI_LabelValues_Call) RunAndReturn(run func(ctx context.Context, label string, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) (model.LabelValues, v1.Warnings, error)) *mockPrometheusAPI_LabelValues_Call {
	_c.Call.Return(run)
	return _c
}

// Metadata provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Metadata(ctx context.Context, metric string, limit string) (map[string][]v1.Metadata, error) {
	ret := _mock.Called(ctx, metric, limit)

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

	var r0 map[string][]v1.Metadata
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (map[string][]v1.Metadata, error)); ok {
		return returnFunc(ctx, metric, limit)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) map[string][]v1.Metadata); ok {
		r0 = returnFunc(ctx, metric, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string][]v1.Metadata)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, metric, limit)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Metadata is a helper method to define mock.On call
//   - ctx context.Context
//   - metric string
//   - limit string
func (_e *mockPrometheusAPI_Expecter) Metadata(ctx interface{}, metric interface{}, limit interface{}) *mockPrometheusAPI_Metadata_Call {
	return &mockPrometheusAPI_Metadata_Call{Call: _e.mock.On("Metadata", ctx, metric, limit)}
}

func (_c *mockPrometheusAPI_Metadata_Call) Run(run func(ctx context.Context, metric string, limit string)) *mockPrometheusAPI_Metadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Metadata_Call) Return(stringToMetadatas map[string][]v1.Metadata, err error) *mockPrometheusAPI_Metadata_Call {
	_c.Call.Return(stringToMetadatas, err)
	return _c
}

func (_c *mockPrometheusAPI_Metadata_Call) RunAndReturn(run func(ctx context.Context, metric string, limit string) (map[string][]v1.Metadata, error)) *mockPrometheusAPI_Metadata_Call {
	_c.Call.Return(run)
	return _c
}

// Query provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Query(ctx context.Context, query string, ts time.Time, opts ...v1.Option) (model.Value, v1.Warnings, error) {
	// v1.Option
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, query, ts)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 model.Value
	var r1 v1.Warnings
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, ...v1.Option) (model.Value, v1.Warnings, error)); ok {
		return returnFunc(ctx, query, ts, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, ...v1.Option) model.Value); ok {
		r0 = returnFunc(ctx, query, ts, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.Value)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, time.Time, ...v1.Option) v1.Warnings); ok {
		r1 = returnFunc(ctx, query, ts, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, time.Time, ...v1.Option) error); ok {
		r2 = returnFunc(ctx, query, ts, opts...)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// Query is a helper method to define mock.On call
//   - ctx context.Context
//   - query string
//   - ts time.Time
//   - opts ...v1.Option
func (_e *mockPrometheusAPI_Expecter) Query(ctx interface{}, query interface{}, ts interface{}, opts ...interface{}) *mockPrometheusAPI_Query_Call {
	return &mockPrometheusAPI_Query_Call{Call: _e.mock.On("Query",
		append([]interface{}{ctx, query, ts}, opts...)...)}
}

func (_c *mockPrometheusAPI_Query_Call) Run(run func(ctx context.Context, query string, ts time.Time, opts ...v1.Option)) *mockPrometheusAPI_Query_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		var arg3 []v1.Option
		variadicArgs := make([]v1.Option, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Query_Call) Return(value model.Value, warnings v1.Warnings, err error) *mockPrometheusAPI_Query_Call {
	_c.Call.Return(value, warnings, err)
	return _c
}

func (_c *mockPrometheusAPI_Query_Call) RunAndReturn(run func(ctx context.Context, query string, ts time.Time, opts ...v1.Option) (model.Value, v1.Warnings, error)) *mockPrometheusAPI_Query_Call {
	_c.Call.Return(run)
	return _c
}

// QueryExemplars provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) QueryExemplars(ctx context.Context, query string, startTime time.Time, endTime time.Time) ([]v1.ExemplarQueryResult, error) {
	ret := _mock.Called(ctx, query, startTime, endTime)

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

	var r0 []v1.ExemplarQueryResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, time.Time) ([]v1.ExemplarQueryResult, error)); ok {
		return returnFunc(ctx, query, startTime, endTime)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, time.Time) []v1.ExemplarQueryResult); ok {
		r0 = returnFunc(ctx, query, startTime, endTime)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v1.ExemplarQueryResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, time.Time, time.Time) error); ok {
		r1 = returnFunc(ctx, query, startTime, endTime)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// QueryExemplars is a helper method to define mock.On call
//   - ctx context.Context
//   - query string
//   - startTime time.Time
//   - endTime time.Time
func (_e *mockPrometheusAPI_Expecter) QueryExemplars(ctx interface{}, query interface{}, startTime interface{}, endTime interface{}) *mockPrometheusAPI_QueryExemplars_Call {
	return &mockPrometheusAPI_QueryExemplars_Call{Call: _e.mock.On("QueryExemplars", ctx, query, startTime, endTime)}
}

func (_c *mockPrometheusAPI_QueryExemplars_Call) Run(run func(ctx context.Context, query string, startTime time.Time, endTime time.Time)) *mockPrometheusAPI_QueryExemplars_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		var arg3 time.Time
		if args[3] != nil {
			arg3 = args[3].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_QueryExemplars_Call) Return(exemplarQueryResults []v1.ExemplarQueryResult, err error) *mockPrometheusAPI_QueryExemplars_Call {
	_c.Call.Return(exemplarQueryResults, err)
	return _c
}

func (_c *mockPrometheusAPI_QueryExemplars_Call) RunAndReturn(run func(ctx context.Context, query string, startTime time.Time, endTime time.Time) ([]v1.ExemplarQueryResult, error)) *mockPrometheusAPI_QueryExemplars_Call {
	_c.Call.Return(run)
	return _c
}

// QueryRange provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) QueryRange(ctx context.Context, query string, r v1.Range, opts ...v1.Option) (model.Value, v1.Warnings, error) {
	// v1.Option
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, query, r)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 model.Value
	var r1 v1.Warnings
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, v1.Range, ...v1.Option) (model.Value, v1.Warnings, error)); ok {
		return returnFunc(ctx, query, r, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, v1.Range, ...v1.Option) model.Value); ok {
		r0 = returnFunc(ctx, query, r, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.Value)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, v1.Range, ...v1.Option) v1.Warnings); ok {
		r1 = returnFunc(ctx, query, r, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, v1.Range, ...v1.Option) error); ok {
		r2 = returnFunc(ctx, query, r, opts...)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// QueryRange is a helper method to define mock.On call
//   - ctx context.Context
//   - query string
//   - r v1.Range
//   - opts ...v1.Option
func (_e *mockPrometheusAPI_Expecter) QueryRange(ctx interface{}, query interface{}, r interface{}, opts ...interface{}) *mockPrometheusAPI_QueryRange_Call {
	return &mockPrometheusAPI_QueryRange_Call{Call: _e.mock.On("QueryRange",
		append([]interface{}{ctx, query, r}, opts...)...)}
}

func (_c *mockPrometheusAPI_QueryRange_Call) Run(run func(ctx context.Context, query string, r v1.Range, opts ...v1.Option)) *mockPrometheusAPI_QueryRange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 v1.Range
		if args[2] != nil {
			arg2 = args[2].(v1.Range)
		}
		var arg3 []v1.Option
		variadicArgs := make([]v1.Option, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		arg3 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3...,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_QueryRange_Call) Return(value model.Value, warnings v1.Warnings, err error) *mockPrometheusAPI_QueryRange_Call {
	_c.Call.Return(value, warnings, err)
	return _c
}

func (_c *mockPrometheusAPI_QueryRange_Call) RunAndReturn(run func(ctx context.Context, query string, r v1.Range, opts ...v1.Option) (model.Value, v1.Warnings, error)) *mockPrometheusAPI_QueryRange_Call {
	_c.Call.Return(run)
	return _c
}

// Rules provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Rules(ctx context.Context) (v1.RulesResult, error) {
	ret := _mock.Called(ctx)

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

	var r0 v1.RulesResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (v1.RulesResult, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) v1.RulesResult); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(v1.RulesResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Rules is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) Rules(ctx interface{}) *mockPrometheusAPI_Rules_Call {
	return &mockPrometheusAPI_Rules_Call{Call: _e.mock.On("Rules", ctx)}
}

func (_c *mockPrometheusAPI_Rules_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_Rules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Rules_Call) Return(rulesResult v1.RulesResult, err error) *mockPrometheusAPI_Rules_Call {
	_c.Call.Return(rulesResult, err)
	return _c
}

func (_c *mockPrometheusAPI_Rules_Call) RunAndReturn(run func(ctx context.Context) (v1.RulesResult, error)) *mockPrometheusAPI_Rules_Call {
	_c.Call.Return(run)
	return _c
}

// Runtimeinfo provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Runtimeinfo(ctx context.Context) (v1.RuntimeinfoResult, error) {
	ret := _mock.Called(ctx)

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

	var r0 v1.RuntimeinfoResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (v1.RuntimeinfoResult, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) v1.RuntimeinfoResult); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(v1.RuntimeinfoResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Runtimeinfo is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) Runtimeinfo(ctx interface{}) *mockPrometheusAPI_Runtimeinfo_Call {
	return &mockPrometheusAPI_Runtimeinfo_Call{Call: _e.mock.On("Runtimeinfo", ctx)}
}

func (_c *mockPrometheusAPI_Runtimeinfo_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_Runtimeinfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Runtimeinfo_Call) Return(runtimeinfoResult v1.RuntimeinfoResult, err error) *mockPrometheusAPI_Runtimeinfo_Call {
	_c.Call.Return(runtimeinfoResult, err)
	return _c
}

func (_c *mockPrometheusAPI_Runtimeinfo_Call) RunAndReturn(run func(ctx context.Context) (v1.RuntimeinfoResult, error)) *mockPrometheusAPI_Runtimeinfo_Call {
	_c.Call.Return(run)
	return _c
}

// Series provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Series(ctx context.Context, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) ([]model.LabelSet, v1.Warnings, error) {
	// v1.Option
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, matches, startTime, endTime)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 []model.LabelSet
	var r1 v1.Warnings
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) ([]model.LabelSet, v1.Warnings, error)); ok {
		return returnFunc(ctx, matches, startTime, endTime, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) []model.LabelSet); ok {
		r0 = returnFunc(ctx, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]model.LabelSet)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) v1.Warnings); ok {
		r1 = returnFunc(ctx, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) error); ok {
		r2 = returnFunc(ctx, matches, startTime, endTime, opts...)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// Series is a helper method to define mock.On call
//   - ctx context.Context
//   - matches []string
//   - startTime time.Time
//   - endTime time.Time
//   - opts ...v1.Option
func (_e *mockPrometheusAPI_Expecter) Series(ctx interface{}, matches interface{}, startTime interface{}, endTime interface{}, opts ...interface{}) *mockPrometheusAPI_Series_Call {
	return &mockPrometheusAPI_Series_Call{Call: _e.mock.On("Series",
		append([]interface{}{ctx, matches, startTime, endTime}, opts...)...)}
}

func (_c *mockPrometheusAPI_Series_Call) Run(run func(ctx context.Context, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option)) *mockPrometheusAPI_Series_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		var arg3 time.Time
		if args[3] != nil {
			arg3 = args[3].(time.Time)
		}
		var arg4 []v1.Option
		variadicArgs := make([]v1.Option, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		arg4 = variadicArgs
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4...,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Series_Call) Return(labelSets []model.LabelSet, warnings v1.Warnings, err error) *mockPrometheusAPI_Series_Call {
	_c.Call.Return(labelSets, warnings, err)
	return _c
}

func (_c *mockPrometheusAPI_Series_Call) RunAndReturn(run func(ctx context.Context, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) ([]model.LabelSet, v1.Warnings, error)) *mockPrometheusAPI_Series_Call {
	_c.Call.Return(run)
	return _c
}

// Snapshot provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Snapshot(ctx context.Context, skipHead bool) (v1.SnapshotResult, error) {
	ret := _mock.Called(ctx, skipHead)

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

	var r0 v1.SnapshotResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, bool) (v1.SnapshotResult, error)); ok {
		return returnFunc(ctx, skipHead)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, bool) v1.SnapshotResult); ok {
		r0 = returnFunc(ctx, skipHead)
	} else {
		r0 = ret.Get(0).(v1.SnapshotResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, bool) error); ok {
		r1 = returnFunc(ctx, skipHead)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Snapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - skipHead bool
func (_e *mockPrometheusAPI_Expecter) Snapshot(ctx interface{}, skipHead interface{}) *mockPrometheusAPI_Snapshot_Call {
	return &mockPrometheusAPI_Snapshot_Call{Call: _e.mock.On("Snapshot", ctx, skipHead)}
}

func (_c *mockPrometheusAPI_Snapshot_Call) Run(run func(ctx context.Context, skipHead bool)) *mockPrometheusAPI_Snapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Snapshot_Call) Return(snapshotResult v1.SnapshotResult, err error) *mockPrometheusAPI_Snapshot_Call {
	_c.Call.Return(snapshotResult, err)
	return _c
}

func (_c *mockPrometheusAPI_Snapshot_Call) RunAndReturn(run func(ctx context.Context, skipHead bool) (v1.SnapshotResult, error)) *mockPrometheusAPI_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}

// TSDB provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) TSDB(ctx context.Context, opts ...v1.Option) (v1.TSDBResult, error) {
	// v1.Option
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

	var r0 v1.TSDBResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...v1.Option) (v1.TSDBResult, error)); ok {
		return returnFunc(ctx, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, ...v1.Option) v1.TSDBResult); ok {
		r0 = returnFunc(ctx, opts...)
	} else {
		r0 = ret.Get(0).(v1.TSDBResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, ...v1.Option) error); ok {
		r1 = returnFunc(ctx, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// TSDB is a helper method to define mock.On call
//   - ctx context.Context
//   - opts ...v1.Option
func (_e *mockPrometheusAPI_Expecter) TSDB(ctx interface{}, opts ...interface{}) *mockPrometheusAPI_TSDB_Call {
	return &mockPrometheusAPI_TSDB_Call{Call: _e.mock.On("TSDB",
		append([]interface{}{ctx}, opts...)...)}
}

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

func (_c *mockPrometheusAPI_TSDB_Call) Return(tSDBResult v1.TSDBResult, err error) *mockPrometheusAPI_TSDB_Call {
	_c.Call.Return(tSDBResult, err)
	return _c
}

func (_c *mockPrometheusAPI_TSDB_Call) RunAndReturn(run func(ctx context.Context, opts ...v1.Option) (v1.TSDBResult, error)) *mockPrometheusAPI_TSDB_Call {
	_c.Call.Return(run)
	return _c
}

// Targets provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) Targets(ctx context.Context) (v1.TargetsResult, error) {
	ret := _mock.Called(ctx)

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

	var r0 v1.TargetsResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (v1.TargetsResult, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) v1.TargetsResult); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(v1.TargetsResult)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Targets is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) Targets(ctx interface{}) *mockPrometheusAPI_Targets_Call {
	return &mockPrometheusAPI_Targets_Call{Call: _e.mock.On("Targets", ctx)}
}

func (_c *mockPrometheusAPI_Targets_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_Targets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_Targets_Call) Return(targetsResult v1.TargetsResult, err error) *mockPrometheusAPI_Targets_Call {
	_c.Call.Return(targetsResult, err)
	return _c
}

func (_c *mockPrometheusAPI_Targets_Call) RunAndReturn(run func(ctx context.Context) (v1.TargetsResult, error)) *mockPrometheusAPI_Targets_Call {
	_c.Call.Return(run)
	return _c
}

// TargetsMetadata provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) TargetsMetadata(ctx context.Context, matchTarget string, metric string, limit string) ([]v1.MetricMetadata, error) {
	ret := _mock.Called(ctx, matchTarget, metric, limit)

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

	var r0 []v1.MetricMetadata
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) ([]v1.MetricMetadata, error)); ok {
		return returnFunc(ctx, matchTarget, metric, limit)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) []v1.MetricMetadata); ok {
		r0 = returnFunc(ctx, matchTarget, metric, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v1.MetricMetadata)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, matchTarget, metric, limit)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// TargetsMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - matchTarget string
//   - metric string
//   - limit string
func (_e *mockPrometheusAPI_Expecter) TargetsMetadata(ctx interface{}, matchTarget interface{}, metric interface{}, limit interface{}) *mockPrometheusAPI_TargetsMetadata_Call {
	return &mockPrometheusAPI_TargetsMetadata_Call{Call: _e.mock.On("TargetsMetadata", ctx, matchTarget, metric, limit)}
}

func (_c *mockPrometheusAPI_TargetsMetadata_Call) Run(run func(ctx context.Context, matchTarget string, metric string, limit string)) *mockPrometheusAPI_TargetsMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_TargetsMetadata_Call) Return(metricMetadatas []v1.MetricMetadata, err error) *mockPrometheusAPI_TargetsMetadata_Call {
	_c.Call.Return(metricMetadatas, err)
	return _c
}

func (_c *mockPrometheusAPI_TargetsMetadata_Call) RunAndReturn(run func(ctx context.Context, matchTarget string, metric string, limit string) ([]v1.MetricMetadata, error)) *mockPrometheusAPI_TargetsMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// WalReplay provides a mock function for the type mockPrometheusAPI
func (_mock *mockPrometheusAPI) WalReplay(ctx context.Context) (v1.WalReplayStatus, error) {
	ret := _mock.Called(ctx)

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

	var r0 v1.WalReplayStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (v1.WalReplayStatus, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) v1.WalReplayStatus); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(v1.WalReplayStatus)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// WalReplay is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockPrometheusAPI_Expecter) WalReplay(ctx interface{}) *mockPrometheusAPI_WalReplay_Call {
	return &mockPrometheusAPI_WalReplay_Call{Call: _e.mock.On("WalReplay", ctx)}
}

func (_c *mockPrometheusAPI_WalReplay_Call) Run(run func(ctx context.Context)) *mockPrometheusAPI_WalReplay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockPrometheusAPI_WalReplay_Call) Return(walReplayStatus v1.WalReplayStatus, err error) *mockPrometheusAPI_WalReplay_Call {
	_c.Call.Return(walReplayStatus, err)
	return _c
}

func (_c *mockPrometheusAPI_WalReplay_Call) RunAndReturn(run func(ctx context.Context) (v1.WalReplayStatus, error)) *mockPrometheusAPI_WalReplay_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type mockPrometheusValue_Expecter struct {
	mock *mock.Mock
}

func (_m *mockPrometheusValue) EXPECT() *mockPrometheusValue_Expecter {
	return &mockPrometheusValue_Expecter{mock: &_m.Mock}
}

// String provides a mock function for the type mockPrometheusValue
func (_mock *mockPrometheusValue) String() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// String is a helper method to define mock.On call
func (_e *mockPrometheusValue_Expecter) String() *mockPrometheusValue_String_Call {
	return &mockPrometheusValue_String_Call{Call: _e.mock.On("String")}
}

func (_c *mockPrometheusValue_String_Call) Run(run func()) *mockPrometheusValue_String_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockPrometheusValue_String_Call) Return(s string) *mockPrometheusValue_String_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *mockPrometheusValue_String_Call) RunAndReturn(run func() string) *mockPrometheusValue_String_Call {
	_c.Call.Return(run)
	return _c
}

// Type provides a mock function for the type mockPrometheusValue
func (_mock *mockPrometheusValue) Type() model.ValueType {
	ret := _mock.Called()

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

	var r0 model.ValueType
	if returnFunc, ok := ret.Get(0).(func() model.ValueType); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(model.ValueType)
	}
	return r0
}

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

// Type is a helper method to define mock.On call
func (_e *mockPrometheusValue_Expecter) Type() *mockPrometheusValue_Type_Call {
	return &mockPrometheusValue_Type_Call{Call: _e.mock.On("Type")}
}

func (_c *mockPrometheusValue_Type_Call) Run(run func()) *mockPrometheusValue_Type_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockPrometheusValue_Type_Call) Return(valueType model.ValueType) *mockPrometheusValue_Type_Call {
	_c.Call.Return(valueType)
	return _c
}

func (_c *mockPrometheusValue_Type_Call) RunAndReturn(run func() model.ValueType) *mockPrometheusValue_Type_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockReferee_Expecter struct {
	mock *mock.Mock
}

func (_m *MockReferee) EXPECT() *MockReferee_Expecter {
	return &MockReferee_Expecter{mock: &_m.Mock}
}

// ArtifactBaseName provides a mock function for the type MockReferee
func (_mock *MockReferee) ArtifactBaseName() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// ArtifactBaseName is a helper method to define mock.On call
func (_e *MockReferee_Expecter) ArtifactBaseName() *MockReferee_ArtifactBaseName_Call {
	return &MockReferee_ArtifactBaseName_Call{Call: _e.mock.On("ArtifactBaseName")}
}

func (_c *MockReferee_ArtifactBaseName_Call) Run(run func()) *MockReferee_ArtifactBaseName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockReferee_ArtifactBaseName_Call) Return(s string) *MockReferee_ArtifactBaseName_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockReferee_ArtifactBaseName_Call) RunAndReturn(run func() string) *MockReferee_ArtifactBaseName_Call {
	_c.Call.Return(run)
	return _c
}

// ArtifactFormat provides a mock function for the type MockReferee
func (_mock *MockReferee) ArtifactFormat() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// ArtifactFormat is a helper method to define mock.On call
func (_e *MockReferee_Expecter) ArtifactFormat() *MockReferee_ArtifactFormat_Call {
	return &MockReferee_ArtifactFormat_Call{Call: _e.mock.On("ArtifactFormat")}
}

func (_c *MockReferee_ArtifactFormat_Call) Run(run func()) *MockReferee_ArtifactFormat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockReferee_ArtifactFormat_Call) Return(s string) *MockReferee_ArtifactFormat_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockReferee_ArtifactFormat_Call) RunAndReturn(run func() string) *MockReferee_ArtifactFormat_Call {
	_c.Call.Return(run)
	return _c
}

// ArtifactType provides a mock function for the type MockReferee
func (_mock *MockReferee) ArtifactType() string {
	ret := _mock.Called()

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// ArtifactType is a helper method to define mock.On call
func (_e *MockReferee_Expecter) ArtifactType() *MockReferee_ArtifactType_Call {
	return &MockReferee_ArtifactType_Call{Call: _e.mock.On("ArtifactType")}
}

func (_c *MockReferee_ArtifactType_Call) Run(run func()) *MockReferee_ArtifactType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockReferee_ArtifactType_Call) Return(s string) *MockReferee_ArtifactType_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockReferee_ArtifactType_Call) RunAndReturn(run func() string) *MockReferee_ArtifactType_Call {
	_c.Call.Return(run)
	return _c
}

// Execute provides a mock function for the type MockReferee
func (_mock *MockReferee) Execute(ctx context.Context, startTime time.Time, endTime time.Time) (*bytes.Reader, error) {
	ret := _mock.Called(ctx, startTime, endTime)

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

	var r0 *bytes.Reader
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, time.Time) (*bytes.Reader, error)); ok {
		return returnFunc(ctx, startTime, endTime)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, time.Time) *bytes.Reader); ok {
		r0 = returnFunc(ctx, startTime, endTime)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*bytes.Reader)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time, time.Time) error); ok {
		r1 = returnFunc(ctx, startTime, endTime)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Execute is a helper method to define mock.On call
//   - ctx context.Context
//   - startTime time.Time
//   - endTime time.Time
func (_e *MockReferee_Expecter) Execute(ctx interface{}, startTime interface{}, endTime interface{}) *MockReferee_Execute_Call {
	return &MockReferee_Execute_Call{Call: _e.mock.On("Execute", ctx, startTime, endTime)}
}

func (_c *MockReferee_Execute_Call) Run(run func(ctx context.Context, startTime time.Time, endTime time.Time)) *MockReferee_Execute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 time.Time
		if args[1] != nil {
			arg1 = args[1].(time.Time)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockReferee_Execute_Call) Return(reader *bytes.Reader, err error) *MockReferee_Execute_Call {
	_c.Call.Return(reader, err)
	return _c
}

func (_c *MockReferee_Execute_Call) RunAndReturn(run func(ctx context.Context, startTime time.Time, endTime time.Time) (*bytes.Reader, error)) *MockReferee_Execute_Call {
	_c.Call.Return(run)
	return _c
}
