referees/mock_prometheusAPI.go

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

package referees

import (
	context "context"

	model "github.com/prometheus/common/model"
	mock "github.com/stretchr/testify/mock"

	time "time"

	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
)

// 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 with given fields: ctx
func (_m *mockPrometheusAPI) AlertManagers(ctx context.Context) (v1.AlertManagersResult, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// Alerts provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) Alerts(ctx context.Context) (v1.AlertsResult, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// Buildinfo provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) Buildinfo(ctx context.Context) (v1.BuildinfoResult, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// CleanTombstones provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) CleanTombstones(ctx context.Context) error {
	ret := _m.Called(ctx)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// Config provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) Config(ctx context.Context) (v1.ConfigResult, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// DeleteSeries provides a mock function with given fields: ctx, matches, startTime, endTime
func (_m *mockPrometheusAPI) DeleteSeries(ctx context.Context, matches []string, startTime time.Time, endTime time.Time) error {
	ret := _m.Called(ctx, matches, startTime, endTime)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, []string, time.Time, time.Time) error); ok {
		r0 = rf(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) {
		run(args[0].(context.Context), args[1].([]string), args[2].(time.Time), args[3].(time.Time))
	})
	return _c
}

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

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

// Flags provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) Flags(ctx context.Context) (v1.FlagsResult, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// LabelNames provides a mock function with given fields: ctx, matches, startTime, endTime, opts
func (_m *mockPrometheusAPI) LabelNames(ctx context.Context, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) ([]string, v1.Warnings, error) {
	_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 := _m.Called(_ca...)

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

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

	if rf, ok := ret.Get(1).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) v1.Warnings); ok {
		r1 = rf(ctx, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) error); ok {
		r2 = rf(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) {
		variadicArgs := make([]v1.Option, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		run(args[0].(context.Context), args[1].([]string), args[2].(time.Time), args[3].(time.Time), variadicArgs...)
	})
	return _c
}

func (_c *mockPrometheusAPI_LabelNames_Call) Return(_a0 []string, _a1 v1.Warnings, _a2 error) *mockPrometheusAPI_LabelNames_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

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

// LabelValues provides a mock function with given fields: ctx, label, matches, startTime, endTime, opts
func (_m *mockPrometheusAPI) LabelValues(ctx context.Context, label string, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) (model.LabelValues, v1.Warnings, error) {
	_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 := _m.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 rf, ok := ret.Get(0).(func(context.Context, string, []string, time.Time, time.Time, ...v1.Option) (model.LabelValues, v1.Warnings, error)); ok {
		return rf(ctx, label, matches, startTime, endTime, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, []string, time.Time, time.Time, ...v1.Option) model.LabelValues); ok {
		r0 = rf(ctx, label, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.LabelValues)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, []string, time.Time, time.Time, ...v1.Option) v1.Warnings); ok {
		r1 = rf(ctx, label, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, string, []string, time.Time, time.Time, ...v1.Option) error); ok {
		r2 = rf(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) {
		variadicArgs := make([]v1.Option, len(args)-5)
		for i, a := range args[5:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].([]string), args[3].(time.Time), args[4].(time.Time), variadicArgs...)
	})
	return _c
}

func (_c *mockPrometheusAPI_LabelValues_Call) Return(_a0 model.LabelValues, _a1 v1.Warnings, _a2 error) *mockPrometheusAPI_LabelValues_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

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

// Metadata provides a mock function with given fields: ctx, metric, limit
func (_m *mockPrometheusAPI) Metadata(ctx context.Context, metric string, limit string) (map[string][]v1.Metadata, error) {
	ret := _m.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 rf, ok := ret.Get(0).(func(context.Context, string, string) (map[string][]v1.Metadata, error)); ok {
		return rf(ctx, metric, limit)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) map[string][]v1.Metadata); ok {
		r0 = rf(ctx, metric, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string][]v1.Metadata)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

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

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

// Query provides a mock function with given fields: ctx, query, ts, opts
func (_m *mockPrometheusAPI) Query(ctx context.Context, query string, ts time.Time, opts ...v1.Option) (model.Value, v1.Warnings, error) {
	_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 := _m.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 rf, ok := ret.Get(0).(func(context.Context, string, time.Time, ...v1.Option) (model.Value, v1.Warnings, error)); ok {
		return rf(ctx, query, ts, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Time, ...v1.Option) model.Value); ok {
		r0 = rf(ctx, query, ts, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.Value)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, time.Time, ...v1.Option) v1.Warnings); ok {
		r1 = rf(ctx, query, ts, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, string, time.Time, ...v1.Option) error); ok {
		r2 = rf(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) {
		variadicArgs := make([]v1.Option, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(time.Time), variadicArgs...)
	})
	return _c
}

func (_c *mockPrometheusAPI_Query_Call) Return(_a0 model.Value, _a1 v1.Warnings, _a2 error) *mockPrometheusAPI_Query_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

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

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

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

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

	if rf, ok := ret.Get(1).(func(context.Context, string, time.Time, time.Time) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context), args[1].(string), args[2].(time.Time), args[3].(time.Time))
	})
	return _c
}

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

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

// QueryRange provides a mock function with given fields: ctx, query, r, opts
func (_m *mockPrometheusAPI) QueryRange(ctx context.Context, query string, r v1.Range, opts ...v1.Option) (model.Value, v1.Warnings, error) {
	_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 := _m.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 rf, ok := ret.Get(0).(func(context.Context, string, v1.Range, ...v1.Option) (model.Value, v1.Warnings, error)); ok {
		return rf(ctx, query, r, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, v1.Range, ...v1.Option) model.Value); ok {
		r0 = rf(ctx, query, r, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.Value)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, v1.Range, ...v1.Option) v1.Warnings); ok {
		r1 = rf(ctx, query, r, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, string, v1.Range, ...v1.Option) error); ok {
		r2 = rf(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) {
		variadicArgs := make([]v1.Option, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(v1.Range), variadicArgs...)
	})
	return _c
}

func (_c *mockPrometheusAPI_QueryRange_Call) Return(_a0 model.Value, _a1 v1.Warnings, _a2 error) *mockPrometheusAPI_QueryRange_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

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

// Rules provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) Rules(ctx context.Context) (v1.RulesResult, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// Runtimeinfo provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) Runtimeinfo(ctx context.Context) (v1.RuntimeinfoResult, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// Series provides a mock function with given fields: ctx, matches, startTime, endTime, opts
func (_m *mockPrometheusAPI) Series(ctx context.Context, matches []string, startTime time.Time, endTime time.Time, opts ...v1.Option) ([]model.LabelSet, v1.Warnings, error) {
	_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 := _m.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 rf, ok := ret.Get(0).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) ([]model.LabelSet, v1.Warnings, error)); ok {
		return rf(ctx, matches, startTime, endTime, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) []model.LabelSet); ok {
		r0 = rf(ctx, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]model.LabelSet)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) v1.Warnings); ok {
		r1 = rf(ctx, matches, startTime, endTime, opts...)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(v1.Warnings)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, []string, time.Time, time.Time, ...v1.Option) error); ok {
		r2 = rf(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) {
		variadicArgs := make([]v1.Option, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		run(args[0].(context.Context), args[1].([]string), args[2].(time.Time), args[3].(time.Time), variadicArgs...)
	})
	return _c
}

func (_c *mockPrometheusAPI_Series_Call) Return(_a0 []model.LabelSet, _a1 v1.Warnings, _a2 error) *mockPrometheusAPI_Series_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

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

// Snapshot provides a mock function with given fields: ctx, skipHead
func (_m *mockPrometheusAPI) Snapshot(ctx context.Context, skipHead bool) (v1.SnapshotResult, error) {
	ret := _m.Called(ctx, skipHead)

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

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

	if rf, ok := ret.Get(1).(func(context.Context, bool) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context), args[1].(bool))
	})
	return _c
}

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

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

// TSDB provides a mock function with given fields: ctx, opts
func (_m *mockPrometheusAPI) TSDB(ctx context.Context, opts ...v1.Option) (v1.TSDBResult, 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 TSDB")
	}

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

	if rf, ok := ret.Get(1).(func(context.Context, ...v1.Option) error); ok {
		r1 = rf(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) {
		variadicArgs := make([]v1.Option, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(v1.Option)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

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

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

// Targets provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) Targets(ctx context.Context) (v1.TargetsResult, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

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

// TargetsMetadata provides a mock function with given fields: ctx, matchTarget, metric, limit
func (_m *mockPrometheusAPI) TargetsMetadata(ctx context.Context, matchTarget string, metric string, limit string) ([]v1.MetricMetadata, error) {
	ret := _m.Called(ctx, matchTarget, metric, limit)

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

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

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

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

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

// WalReplay provides a mock function with given fields: ctx
func (_m *mockPrometheusAPI) WalReplay(ctx context.Context) (v1.WalReplayStatus, error) {
	ret := _m.Called(ctx)

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

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

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(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) {
		run(args[0].(context.Context))
	})
	return _c
}

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

func (_c *mockPrometheusAPI_WalReplay_Call) RunAndReturn(run func(context.Context) (v1.WalReplayStatus, error)) *mockPrometheusAPI_WalReplay_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
}