mock_experiments_interface.go

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

package ml

import (
	context "context"

	listing "github.com/databricks/databricks-sdk-go/listing"
	ml "github.com/databricks/databricks-sdk-go/service/ml"

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

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

type MockExperimentsInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExperimentsInterface) EXPECT() *MockExperimentsInterface_Expecter {
	return &MockExperimentsInterface_Expecter{mock: &_m.Mock}
}

// CreateExperiment provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) CreateExperiment(ctx context.Context, request ml.CreateExperiment) (*ml.CreateExperimentResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.CreateExperimentResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.CreateExperiment) (*ml.CreateExperimentResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.CreateExperiment) *ml.CreateExperimentResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.CreateExperimentResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.CreateExperiment) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateExperiment is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.CreateExperiment
func (_e *MockExperimentsInterface_Expecter) CreateExperiment(ctx interface{}, request interface{}) *MockExperimentsInterface_CreateExperiment_Call {
	return &MockExperimentsInterface_CreateExperiment_Call{Call: _e.mock.On("CreateExperiment", ctx, request)}
}

func (_c *MockExperimentsInterface_CreateExperiment_Call) Run(run func(ctx context.Context, request ml.CreateExperiment)) *MockExperimentsInterface_CreateExperiment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.CreateExperiment))
	})
	return _c
}

func (_c *MockExperimentsInterface_CreateExperiment_Call) Return(_a0 *ml.CreateExperimentResponse, _a1 error) *MockExperimentsInterface_CreateExperiment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_CreateExperiment_Call) RunAndReturn(run func(context.Context, ml.CreateExperiment) (*ml.CreateExperimentResponse, error)) *MockExperimentsInterface_CreateExperiment_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRun provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) CreateRun(ctx context.Context, request ml.CreateRun) (*ml.CreateRunResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.CreateRunResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.CreateRun) (*ml.CreateRunResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.CreateRun) *ml.CreateRunResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.CreateRunResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.CreateRun) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateRun is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.CreateRun
func (_e *MockExperimentsInterface_Expecter) CreateRun(ctx interface{}, request interface{}) *MockExperimentsInterface_CreateRun_Call {
	return &MockExperimentsInterface_CreateRun_Call{Call: _e.mock.On("CreateRun", ctx, request)}
}

func (_c *MockExperimentsInterface_CreateRun_Call) Run(run func(ctx context.Context, request ml.CreateRun)) *MockExperimentsInterface_CreateRun_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.CreateRun))
	})
	return _c
}

func (_c *MockExperimentsInterface_CreateRun_Call) Return(_a0 *ml.CreateRunResponse, _a1 error) *MockExperimentsInterface_CreateRun_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_CreateRun_Call) RunAndReturn(run func(context.Context, ml.CreateRun) (*ml.CreateRunResponse, error)) *MockExperimentsInterface_CreateRun_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteExperiment provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) DeleteExperiment(ctx context.Context, request ml.DeleteExperiment) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.DeleteExperiment) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteExperiment is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.DeleteExperiment
func (_e *MockExperimentsInterface_Expecter) DeleteExperiment(ctx interface{}, request interface{}) *MockExperimentsInterface_DeleteExperiment_Call {
	return &MockExperimentsInterface_DeleteExperiment_Call{Call: _e.mock.On("DeleteExperiment", ctx, request)}
}

func (_c *MockExperimentsInterface_DeleteExperiment_Call) Run(run func(ctx context.Context, request ml.DeleteExperiment)) *MockExperimentsInterface_DeleteExperiment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.DeleteExperiment))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_DeleteExperiment_Call) RunAndReturn(run func(context.Context, ml.DeleteExperiment) error) *MockExperimentsInterface_DeleteExperiment_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRun provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) DeleteRun(ctx context.Context, request ml.DeleteRun) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.DeleteRun) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteRun is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.DeleteRun
func (_e *MockExperimentsInterface_Expecter) DeleteRun(ctx interface{}, request interface{}) *MockExperimentsInterface_DeleteRun_Call {
	return &MockExperimentsInterface_DeleteRun_Call{Call: _e.mock.On("DeleteRun", ctx, request)}
}

func (_c *MockExperimentsInterface_DeleteRun_Call) Run(run func(ctx context.Context, request ml.DeleteRun)) *MockExperimentsInterface_DeleteRun_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.DeleteRun))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_DeleteRun_Call) RunAndReturn(run func(context.Context, ml.DeleteRun) error) *MockExperimentsInterface_DeleteRun_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRuns provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) DeleteRuns(ctx context.Context, request ml.DeleteRuns) (*ml.DeleteRunsResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.DeleteRunsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.DeleteRuns) (*ml.DeleteRunsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.DeleteRuns) *ml.DeleteRunsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.DeleteRunsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.DeleteRuns) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteRuns is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.DeleteRuns
func (_e *MockExperimentsInterface_Expecter) DeleteRuns(ctx interface{}, request interface{}) *MockExperimentsInterface_DeleteRuns_Call {
	return &MockExperimentsInterface_DeleteRuns_Call{Call: _e.mock.On("DeleteRuns", ctx, request)}
}

func (_c *MockExperimentsInterface_DeleteRuns_Call) Run(run func(ctx context.Context, request ml.DeleteRuns)) *MockExperimentsInterface_DeleteRuns_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.DeleteRuns))
	})
	return _c
}

func (_c *MockExperimentsInterface_DeleteRuns_Call) Return(_a0 *ml.DeleteRunsResponse, _a1 error) *MockExperimentsInterface_DeleteRuns_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_DeleteRuns_Call) RunAndReturn(run func(context.Context, ml.DeleteRuns) (*ml.DeleteRunsResponse, error)) *MockExperimentsInterface_DeleteRuns_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTag provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) DeleteTag(ctx context.Context, request ml.DeleteTag) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.DeleteTag) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DeleteTag is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.DeleteTag
func (_e *MockExperimentsInterface_Expecter) DeleteTag(ctx interface{}, request interface{}) *MockExperimentsInterface_DeleteTag_Call {
	return &MockExperimentsInterface_DeleteTag_Call{Call: _e.mock.On("DeleteTag", ctx, request)}
}

func (_c *MockExperimentsInterface_DeleteTag_Call) Run(run func(ctx context.Context, request ml.DeleteTag)) *MockExperimentsInterface_DeleteTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.DeleteTag))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_DeleteTag_Call) RunAndReturn(run func(context.Context, ml.DeleteTag) error) *MockExperimentsInterface_DeleteTag_Call {
	_c.Call.Return(run)
	return _c
}

// GetByName provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) GetByName(ctx context.Context, request ml.GetByNameRequest) (*ml.GetExperimentResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.GetExperimentResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetByNameRequest) (*ml.GetExperimentResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetByNameRequest) *ml.GetExperimentResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.GetExperimentResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.GetByNameRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetByName is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.GetByNameRequest
func (_e *MockExperimentsInterface_Expecter) GetByName(ctx interface{}, request interface{}) *MockExperimentsInterface_GetByName_Call {
	return &MockExperimentsInterface_GetByName_Call{Call: _e.mock.On("GetByName", ctx, request)}
}

func (_c *MockExperimentsInterface_GetByName_Call) Run(run func(ctx context.Context, request ml.GetByNameRequest)) *MockExperimentsInterface_GetByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.GetByNameRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetByName_Call) Return(_a0 *ml.GetExperimentResponse, _a1 error) *MockExperimentsInterface_GetByName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_GetByName_Call) RunAndReturn(run func(context.Context, ml.GetByNameRequest) (*ml.GetExperimentResponse, error)) *MockExperimentsInterface_GetByName_Call {
	_c.Call.Return(run)
	return _c
}

// GetExperiment provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) GetExperiment(ctx context.Context, request ml.GetExperimentRequest) (*ml.GetExperimentResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.GetExperimentResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetExperimentRequest) (*ml.GetExperimentResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetExperimentRequest) *ml.GetExperimentResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.GetExperimentResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.GetExperimentRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetExperiment is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.GetExperimentRequest
func (_e *MockExperimentsInterface_Expecter) GetExperiment(ctx interface{}, request interface{}) *MockExperimentsInterface_GetExperiment_Call {
	return &MockExperimentsInterface_GetExperiment_Call{Call: _e.mock.On("GetExperiment", ctx, request)}
}

func (_c *MockExperimentsInterface_GetExperiment_Call) Run(run func(ctx context.Context, request ml.GetExperimentRequest)) *MockExperimentsInterface_GetExperiment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.GetExperimentRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetExperiment_Call) Return(_a0 *ml.GetExperimentResponse, _a1 error) *MockExperimentsInterface_GetExperiment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_GetExperiment_Call) RunAndReturn(run func(context.Context, ml.GetExperimentRequest) (*ml.GetExperimentResponse, error)) *MockExperimentsInterface_GetExperiment_Call {
	_c.Call.Return(run)
	return _c
}

// GetHistory provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) GetHistory(ctx context.Context, request ml.GetHistoryRequest) listing.Iterator[ml.Metric] {
	ret := _m.Called(ctx, request)

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

	var r0 listing.Iterator[ml.Metric]
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetHistoryRequest) listing.Iterator[ml.Metric]); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(listing.Iterator[ml.Metric])
		}
	}

	return r0
}

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

// GetHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.GetHistoryRequest
func (_e *MockExperimentsInterface_Expecter) GetHistory(ctx interface{}, request interface{}) *MockExperimentsInterface_GetHistory_Call {
	return &MockExperimentsInterface_GetHistory_Call{Call: _e.mock.On("GetHistory", ctx, request)}
}

func (_c *MockExperimentsInterface_GetHistory_Call) Run(run func(ctx context.Context, request ml.GetHistoryRequest)) *MockExperimentsInterface_GetHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.GetHistoryRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetHistory_Call) Return(_a0 listing.Iterator[ml.Metric]) *MockExperimentsInterface_GetHistory_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockExperimentsInterface_GetHistory_Call) RunAndReturn(run func(context.Context, ml.GetHistoryRequest) listing.Iterator[ml.Metric]) *MockExperimentsInterface_GetHistory_Call {
	_c.Call.Return(run)
	return _c
}

// GetHistoryAll provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) GetHistoryAll(ctx context.Context, request ml.GetHistoryRequest) ([]ml.Metric, error) {
	ret := _m.Called(ctx, request)

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

	var r0 []ml.Metric
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetHistoryRequest) ([]ml.Metric, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetHistoryRequest) []ml.Metric); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]ml.Metric)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.GetHistoryRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetHistoryAll is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.GetHistoryRequest
func (_e *MockExperimentsInterface_Expecter) GetHistoryAll(ctx interface{}, request interface{}) *MockExperimentsInterface_GetHistoryAll_Call {
	return &MockExperimentsInterface_GetHistoryAll_Call{Call: _e.mock.On("GetHistoryAll", ctx, request)}
}

func (_c *MockExperimentsInterface_GetHistoryAll_Call) Run(run func(ctx context.Context, request ml.GetHistoryRequest)) *MockExperimentsInterface_GetHistoryAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.GetHistoryRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetHistoryAll_Call) Return(_a0 []ml.Metric, _a1 error) *MockExperimentsInterface_GetHistoryAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_GetHistoryAll_Call) RunAndReturn(run func(context.Context, ml.GetHistoryRequest) ([]ml.Metric, error)) *MockExperimentsInterface_GetHistoryAll_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionLevels provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) GetPermissionLevels(ctx context.Context, request ml.GetExperimentPermissionLevelsRequest) (*ml.GetExperimentPermissionLevelsResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.GetExperimentPermissionLevelsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetExperimentPermissionLevelsRequest) (*ml.GetExperimentPermissionLevelsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetExperimentPermissionLevelsRequest) *ml.GetExperimentPermissionLevelsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.GetExperimentPermissionLevelsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.GetExperimentPermissionLevelsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPermissionLevels is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.GetExperimentPermissionLevelsRequest
func (_e *MockExperimentsInterface_Expecter) GetPermissionLevels(ctx interface{}, request interface{}) *MockExperimentsInterface_GetPermissionLevels_Call {
	return &MockExperimentsInterface_GetPermissionLevels_Call{Call: _e.mock.On("GetPermissionLevels", ctx, request)}
}

func (_c *MockExperimentsInterface_GetPermissionLevels_Call) Run(run func(ctx context.Context, request ml.GetExperimentPermissionLevelsRequest)) *MockExperimentsInterface_GetPermissionLevels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.GetExperimentPermissionLevelsRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetPermissionLevels_Call) Return(_a0 *ml.GetExperimentPermissionLevelsResponse, _a1 error) *MockExperimentsInterface_GetPermissionLevels_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_GetPermissionLevels_Call) RunAndReturn(run func(context.Context, ml.GetExperimentPermissionLevelsRequest) (*ml.GetExperimentPermissionLevelsResponse, error)) *MockExperimentsInterface_GetPermissionLevels_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionLevelsByExperimentId provides a mock function with given fields: ctx, experimentId
func (_m *MockExperimentsInterface) GetPermissionLevelsByExperimentId(ctx context.Context, experimentId string) (*ml.GetExperimentPermissionLevelsResponse, error) {
	ret := _m.Called(ctx, experimentId)

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

	var r0 *ml.GetExperimentPermissionLevelsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*ml.GetExperimentPermissionLevelsResponse, error)); ok {
		return rf(ctx, experimentId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *ml.GetExperimentPermissionLevelsResponse); ok {
		r0 = rf(ctx, experimentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.GetExperimentPermissionLevelsResponse)
		}
	}

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

	return r0, r1
}

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

// GetPermissionLevelsByExperimentId is a helper method to define mock.On call
//   - ctx context.Context
//   - experimentId string
func (_e *MockExperimentsInterface_Expecter) GetPermissionLevelsByExperimentId(ctx interface{}, experimentId interface{}) *MockExperimentsInterface_GetPermissionLevelsByExperimentId_Call {
	return &MockExperimentsInterface_GetPermissionLevelsByExperimentId_Call{Call: _e.mock.On("GetPermissionLevelsByExperimentId", ctx, experimentId)}
}

func (_c *MockExperimentsInterface_GetPermissionLevelsByExperimentId_Call) Run(run func(ctx context.Context, experimentId string)) *MockExperimentsInterface_GetPermissionLevelsByExperimentId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetPermissionLevelsByExperimentId_Call) Return(_a0 *ml.GetExperimentPermissionLevelsResponse, _a1 error) *MockExperimentsInterface_GetPermissionLevelsByExperimentId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_GetPermissionLevelsByExperimentId_Call) RunAndReturn(run func(context.Context, string) (*ml.GetExperimentPermissionLevelsResponse, error)) *MockExperimentsInterface_GetPermissionLevelsByExperimentId_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissions provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) GetPermissions(ctx context.Context, request ml.GetExperimentPermissionsRequest) (*ml.ExperimentPermissions, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.ExperimentPermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetExperimentPermissionsRequest) (*ml.ExperimentPermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetExperimentPermissionsRequest) *ml.ExperimentPermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.ExperimentPermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.GetExperimentPermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.GetExperimentPermissionsRequest
func (_e *MockExperimentsInterface_Expecter) GetPermissions(ctx interface{}, request interface{}) *MockExperimentsInterface_GetPermissions_Call {
	return &MockExperimentsInterface_GetPermissions_Call{Call: _e.mock.On("GetPermissions", ctx, request)}
}

func (_c *MockExperimentsInterface_GetPermissions_Call) Run(run func(ctx context.Context, request ml.GetExperimentPermissionsRequest)) *MockExperimentsInterface_GetPermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.GetExperimentPermissionsRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetPermissions_Call) Return(_a0 *ml.ExperimentPermissions, _a1 error) *MockExperimentsInterface_GetPermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_GetPermissions_Call) RunAndReturn(run func(context.Context, ml.GetExperimentPermissionsRequest) (*ml.ExperimentPermissions, error)) *MockExperimentsInterface_GetPermissions_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionsByExperimentId provides a mock function with given fields: ctx, experimentId
func (_m *MockExperimentsInterface) GetPermissionsByExperimentId(ctx context.Context, experimentId string) (*ml.ExperimentPermissions, error) {
	ret := _m.Called(ctx, experimentId)

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

	var r0 *ml.ExperimentPermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*ml.ExperimentPermissions, error)); ok {
		return rf(ctx, experimentId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *ml.ExperimentPermissions); ok {
		r0 = rf(ctx, experimentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.ExperimentPermissions)
		}
	}

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

	return r0, r1
}

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

// GetPermissionsByExperimentId is a helper method to define mock.On call
//   - ctx context.Context
//   - experimentId string
func (_e *MockExperimentsInterface_Expecter) GetPermissionsByExperimentId(ctx interface{}, experimentId interface{}) *MockExperimentsInterface_GetPermissionsByExperimentId_Call {
	return &MockExperimentsInterface_GetPermissionsByExperimentId_Call{Call: _e.mock.On("GetPermissionsByExperimentId", ctx, experimentId)}
}

func (_c *MockExperimentsInterface_GetPermissionsByExperimentId_Call) Run(run func(ctx context.Context, experimentId string)) *MockExperimentsInterface_GetPermissionsByExperimentId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetPermissionsByExperimentId_Call) Return(_a0 *ml.ExperimentPermissions, _a1 error) *MockExperimentsInterface_GetPermissionsByExperimentId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_GetPermissionsByExperimentId_Call) RunAndReturn(run func(context.Context, string) (*ml.ExperimentPermissions, error)) *MockExperimentsInterface_GetPermissionsByExperimentId_Call {
	_c.Call.Return(run)
	return _c
}

// GetRun provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) GetRun(ctx context.Context, request ml.GetRunRequest) (*ml.GetRunResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.GetRunResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetRunRequest) (*ml.GetRunResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.GetRunRequest) *ml.GetRunResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.GetRunResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.GetRunRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetRun is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.GetRunRequest
func (_e *MockExperimentsInterface_Expecter) GetRun(ctx interface{}, request interface{}) *MockExperimentsInterface_GetRun_Call {
	return &MockExperimentsInterface_GetRun_Call{Call: _e.mock.On("GetRun", ctx, request)}
}

func (_c *MockExperimentsInterface_GetRun_Call) Run(run func(ctx context.Context, request ml.GetRunRequest)) *MockExperimentsInterface_GetRun_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.GetRunRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_GetRun_Call) Return(_a0 *ml.GetRunResponse, _a1 error) *MockExperimentsInterface_GetRun_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_GetRun_Call) RunAndReturn(run func(context.Context, ml.GetRunRequest) (*ml.GetRunResponse, error)) *MockExperimentsInterface_GetRun_Call {
	_c.Call.Return(run)
	return _c
}

// Impl provides a mock function with given fields:
func (_m *MockExperimentsInterface) Impl() ml.ExperimentsService {
	ret := _m.Called()

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

	var r0 ml.ExperimentsService
	if rf, ok := ret.Get(0).(func() ml.ExperimentsService); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ml.ExperimentsService)
		}
	}

	return r0
}

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

// Impl is a helper method to define mock.On call
func (_e *MockExperimentsInterface_Expecter) Impl() *MockExperimentsInterface_Impl_Call {
	return &MockExperimentsInterface_Impl_Call{Call: _e.mock.On("Impl")}
}

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

func (_c *MockExperimentsInterface_Impl_Call) Return(_a0 ml.ExperimentsService) *MockExperimentsInterface_Impl_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockExperimentsInterface_Impl_Call) RunAndReturn(run func() ml.ExperimentsService) *MockExperimentsInterface_Impl_Call {
	_c.Call.Return(run)
	return _c
}

// ListArtifacts provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) ListArtifacts(ctx context.Context, request ml.ListArtifactsRequest) listing.Iterator[ml.FileInfo] {
	ret := _m.Called(ctx, request)

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

	var r0 listing.Iterator[ml.FileInfo]
	if rf, ok := ret.Get(0).(func(context.Context, ml.ListArtifactsRequest) listing.Iterator[ml.FileInfo]); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(listing.Iterator[ml.FileInfo])
		}
	}

	return r0
}

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

// ListArtifacts is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.ListArtifactsRequest
func (_e *MockExperimentsInterface_Expecter) ListArtifacts(ctx interface{}, request interface{}) *MockExperimentsInterface_ListArtifacts_Call {
	return &MockExperimentsInterface_ListArtifacts_Call{Call: _e.mock.On("ListArtifacts", ctx, request)}
}

func (_c *MockExperimentsInterface_ListArtifacts_Call) Run(run func(ctx context.Context, request ml.ListArtifactsRequest)) *MockExperimentsInterface_ListArtifacts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.ListArtifactsRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_ListArtifacts_Call) Return(_a0 listing.Iterator[ml.FileInfo]) *MockExperimentsInterface_ListArtifacts_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockExperimentsInterface_ListArtifacts_Call) RunAndReturn(run func(context.Context, ml.ListArtifactsRequest) listing.Iterator[ml.FileInfo]) *MockExperimentsInterface_ListArtifacts_Call {
	_c.Call.Return(run)
	return _c
}

// ListArtifactsAll provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) ListArtifactsAll(ctx context.Context, request ml.ListArtifactsRequest) ([]ml.FileInfo, error) {
	ret := _m.Called(ctx, request)

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

	var r0 []ml.FileInfo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.ListArtifactsRequest) ([]ml.FileInfo, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.ListArtifactsRequest) []ml.FileInfo); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]ml.FileInfo)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.ListArtifactsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListArtifactsAll is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.ListArtifactsRequest
func (_e *MockExperimentsInterface_Expecter) ListArtifactsAll(ctx interface{}, request interface{}) *MockExperimentsInterface_ListArtifactsAll_Call {
	return &MockExperimentsInterface_ListArtifactsAll_Call{Call: _e.mock.On("ListArtifactsAll", ctx, request)}
}

func (_c *MockExperimentsInterface_ListArtifactsAll_Call) Run(run func(ctx context.Context, request ml.ListArtifactsRequest)) *MockExperimentsInterface_ListArtifactsAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.ListArtifactsRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_ListArtifactsAll_Call) Return(_a0 []ml.FileInfo, _a1 error) *MockExperimentsInterface_ListArtifactsAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_ListArtifactsAll_Call) RunAndReturn(run func(context.Context, ml.ListArtifactsRequest) ([]ml.FileInfo, error)) *MockExperimentsInterface_ListArtifactsAll_Call {
	_c.Call.Return(run)
	return _c
}

// ListExperiments provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) ListExperiments(ctx context.Context, request ml.ListExperimentsRequest) listing.Iterator[ml.Experiment] {
	ret := _m.Called(ctx, request)

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

	var r0 listing.Iterator[ml.Experiment]
	if rf, ok := ret.Get(0).(func(context.Context, ml.ListExperimentsRequest) listing.Iterator[ml.Experiment]); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(listing.Iterator[ml.Experiment])
		}
	}

	return r0
}

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

// ListExperiments is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.ListExperimentsRequest
func (_e *MockExperimentsInterface_Expecter) ListExperiments(ctx interface{}, request interface{}) *MockExperimentsInterface_ListExperiments_Call {
	return &MockExperimentsInterface_ListExperiments_Call{Call: _e.mock.On("ListExperiments", ctx, request)}
}

func (_c *MockExperimentsInterface_ListExperiments_Call) Run(run func(ctx context.Context, request ml.ListExperimentsRequest)) *MockExperimentsInterface_ListExperiments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.ListExperimentsRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_ListExperiments_Call) Return(_a0 listing.Iterator[ml.Experiment]) *MockExperimentsInterface_ListExperiments_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockExperimentsInterface_ListExperiments_Call) RunAndReturn(run func(context.Context, ml.ListExperimentsRequest) listing.Iterator[ml.Experiment]) *MockExperimentsInterface_ListExperiments_Call {
	_c.Call.Return(run)
	return _c
}

// ListExperimentsAll provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) ListExperimentsAll(ctx context.Context, request ml.ListExperimentsRequest) ([]ml.Experiment, error) {
	ret := _m.Called(ctx, request)

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

	var r0 []ml.Experiment
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.ListExperimentsRequest) ([]ml.Experiment, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.ListExperimentsRequest) []ml.Experiment); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]ml.Experiment)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.ListExperimentsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListExperimentsAll is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.ListExperimentsRequest
func (_e *MockExperimentsInterface_Expecter) ListExperimentsAll(ctx interface{}, request interface{}) *MockExperimentsInterface_ListExperimentsAll_Call {
	return &MockExperimentsInterface_ListExperimentsAll_Call{Call: _e.mock.On("ListExperimentsAll", ctx, request)}
}

func (_c *MockExperimentsInterface_ListExperimentsAll_Call) Run(run func(ctx context.Context, request ml.ListExperimentsRequest)) *MockExperimentsInterface_ListExperimentsAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.ListExperimentsRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_ListExperimentsAll_Call) Return(_a0 []ml.Experiment, _a1 error) *MockExperimentsInterface_ListExperimentsAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_ListExperimentsAll_Call) RunAndReturn(run func(context.Context, ml.ListExperimentsRequest) ([]ml.Experiment, error)) *MockExperimentsInterface_ListExperimentsAll_Call {
	_c.Call.Return(run)
	return _c
}

// LogBatch provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) LogBatch(ctx context.Context, request ml.LogBatch) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.LogBatch) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LogBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.LogBatch
func (_e *MockExperimentsInterface_Expecter) LogBatch(ctx interface{}, request interface{}) *MockExperimentsInterface_LogBatch_Call {
	return &MockExperimentsInterface_LogBatch_Call{Call: _e.mock.On("LogBatch", ctx, request)}
}

func (_c *MockExperimentsInterface_LogBatch_Call) Run(run func(ctx context.Context, request ml.LogBatch)) *MockExperimentsInterface_LogBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.LogBatch))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_LogBatch_Call) RunAndReturn(run func(context.Context, ml.LogBatch) error) *MockExperimentsInterface_LogBatch_Call {
	_c.Call.Return(run)
	return _c
}

// LogInputs provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) LogInputs(ctx context.Context, request ml.LogInputs) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.LogInputs) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LogInputs is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.LogInputs
func (_e *MockExperimentsInterface_Expecter) LogInputs(ctx interface{}, request interface{}) *MockExperimentsInterface_LogInputs_Call {
	return &MockExperimentsInterface_LogInputs_Call{Call: _e.mock.On("LogInputs", ctx, request)}
}

func (_c *MockExperimentsInterface_LogInputs_Call) Run(run func(ctx context.Context, request ml.LogInputs)) *MockExperimentsInterface_LogInputs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.LogInputs))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_LogInputs_Call) RunAndReturn(run func(context.Context, ml.LogInputs) error) *MockExperimentsInterface_LogInputs_Call {
	_c.Call.Return(run)
	return _c
}

// LogMetric provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) LogMetric(ctx context.Context, request ml.LogMetric) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.LogMetric) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LogMetric is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.LogMetric
func (_e *MockExperimentsInterface_Expecter) LogMetric(ctx interface{}, request interface{}) *MockExperimentsInterface_LogMetric_Call {
	return &MockExperimentsInterface_LogMetric_Call{Call: _e.mock.On("LogMetric", ctx, request)}
}

func (_c *MockExperimentsInterface_LogMetric_Call) Run(run func(ctx context.Context, request ml.LogMetric)) *MockExperimentsInterface_LogMetric_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.LogMetric))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_LogMetric_Call) RunAndReturn(run func(context.Context, ml.LogMetric) error) *MockExperimentsInterface_LogMetric_Call {
	_c.Call.Return(run)
	return _c
}

// LogModel provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) LogModel(ctx context.Context, request ml.LogModel) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.LogModel) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LogModel is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.LogModel
func (_e *MockExperimentsInterface_Expecter) LogModel(ctx interface{}, request interface{}) *MockExperimentsInterface_LogModel_Call {
	return &MockExperimentsInterface_LogModel_Call{Call: _e.mock.On("LogModel", ctx, request)}
}

func (_c *MockExperimentsInterface_LogModel_Call) Run(run func(ctx context.Context, request ml.LogModel)) *MockExperimentsInterface_LogModel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.LogModel))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_LogModel_Call) RunAndReturn(run func(context.Context, ml.LogModel) error) *MockExperimentsInterface_LogModel_Call {
	_c.Call.Return(run)
	return _c
}

// LogParam provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) LogParam(ctx context.Context, request ml.LogParam) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.LogParam) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LogParam is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.LogParam
func (_e *MockExperimentsInterface_Expecter) LogParam(ctx interface{}, request interface{}) *MockExperimentsInterface_LogParam_Call {
	return &MockExperimentsInterface_LogParam_Call{Call: _e.mock.On("LogParam", ctx, request)}
}

func (_c *MockExperimentsInterface_LogParam_Call) Run(run func(ctx context.Context, request ml.LogParam)) *MockExperimentsInterface_LogParam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.LogParam))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_LogParam_Call) RunAndReturn(run func(context.Context, ml.LogParam) error) *MockExperimentsInterface_LogParam_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreExperiment provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) RestoreExperiment(ctx context.Context, request ml.RestoreExperiment) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.RestoreExperiment) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RestoreExperiment is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.RestoreExperiment
func (_e *MockExperimentsInterface_Expecter) RestoreExperiment(ctx interface{}, request interface{}) *MockExperimentsInterface_RestoreExperiment_Call {
	return &MockExperimentsInterface_RestoreExperiment_Call{Call: _e.mock.On("RestoreExperiment", ctx, request)}
}

func (_c *MockExperimentsInterface_RestoreExperiment_Call) Run(run func(ctx context.Context, request ml.RestoreExperiment)) *MockExperimentsInterface_RestoreExperiment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.RestoreExperiment))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_RestoreExperiment_Call) RunAndReturn(run func(context.Context, ml.RestoreExperiment) error) *MockExperimentsInterface_RestoreExperiment_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreRun provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) RestoreRun(ctx context.Context, request ml.RestoreRun) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.RestoreRun) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RestoreRun is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.RestoreRun
func (_e *MockExperimentsInterface_Expecter) RestoreRun(ctx interface{}, request interface{}) *MockExperimentsInterface_RestoreRun_Call {
	return &MockExperimentsInterface_RestoreRun_Call{Call: _e.mock.On("RestoreRun", ctx, request)}
}

func (_c *MockExperimentsInterface_RestoreRun_Call) Run(run func(ctx context.Context, request ml.RestoreRun)) *MockExperimentsInterface_RestoreRun_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.RestoreRun))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_RestoreRun_Call) RunAndReturn(run func(context.Context, ml.RestoreRun) error) *MockExperimentsInterface_RestoreRun_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreRuns provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) RestoreRuns(ctx context.Context, request ml.RestoreRuns) (*ml.RestoreRunsResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.RestoreRunsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.RestoreRuns) (*ml.RestoreRunsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.RestoreRuns) *ml.RestoreRunsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.RestoreRunsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.RestoreRuns) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RestoreRuns is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.RestoreRuns
func (_e *MockExperimentsInterface_Expecter) RestoreRuns(ctx interface{}, request interface{}) *MockExperimentsInterface_RestoreRuns_Call {
	return &MockExperimentsInterface_RestoreRuns_Call{Call: _e.mock.On("RestoreRuns", ctx, request)}
}

func (_c *MockExperimentsInterface_RestoreRuns_Call) Run(run func(ctx context.Context, request ml.RestoreRuns)) *MockExperimentsInterface_RestoreRuns_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.RestoreRuns))
	})
	return _c
}

func (_c *MockExperimentsInterface_RestoreRuns_Call) Return(_a0 *ml.RestoreRunsResponse, _a1 error) *MockExperimentsInterface_RestoreRuns_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_RestoreRuns_Call) RunAndReturn(run func(context.Context, ml.RestoreRuns) (*ml.RestoreRunsResponse, error)) *MockExperimentsInterface_RestoreRuns_Call {
	_c.Call.Return(run)
	return _c
}

// SearchExperiments provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) SearchExperiments(ctx context.Context, request ml.SearchExperiments) listing.Iterator[ml.Experiment] {
	ret := _m.Called(ctx, request)

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

	var r0 listing.Iterator[ml.Experiment]
	if rf, ok := ret.Get(0).(func(context.Context, ml.SearchExperiments) listing.Iterator[ml.Experiment]); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(listing.Iterator[ml.Experiment])
		}
	}

	return r0
}

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

// SearchExperiments is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.SearchExperiments
func (_e *MockExperimentsInterface_Expecter) SearchExperiments(ctx interface{}, request interface{}) *MockExperimentsInterface_SearchExperiments_Call {
	return &MockExperimentsInterface_SearchExperiments_Call{Call: _e.mock.On("SearchExperiments", ctx, request)}
}

func (_c *MockExperimentsInterface_SearchExperiments_Call) Run(run func(ctx context.Context, request ml.SearchExperiments)) *MockExperimentsInterface_SearchExperiments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.SearchExperiments))
	})
	return _c
}

func (_c *MockExperimentsInterface_SearchExperiments_Call) Return(_a0 listing.Iterator[ml.Experiment]) *MockExperimentsInterface_SearchExperiments_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockExperimentsInterface_SearchExperiments_Call) RunAndReturn(run func(context.Context, ml.SearchExperiments) listing.Iterator[ml.Experiment]) *MockExperimentsInterface_SearchExperiments_Call {
	_c.Call.Return(run)
	return _c
}

// SearchExperimentsAll provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) SearchExperimentsAll(ctx context.Context, request ml.SearchExperiments) ([]ml.Experiment, error) {
	ret := _m.Called(ctx, request)

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

	var r0 []ml.Experiment
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.SearchExperiments) ([]ml.Experiment, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.SearchExperiments) []ml.Experiment); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]ml.Experiment)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.SearchExperiments) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SearchExperimentsAll is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.SearchExperiments
func (_e *MockExperimentsInterface_Expecter) SearchExperimentsAll(ctx interface{}, request interface{}) *MockExperimentsInterface_SearchExperimentsAll_Call {
	return &MockExperimentsInterface_SearchExperimentsAll_Call{Call: _e.mock.On("SearchExperimentsAll", ctx, request)}
}

func (_c *MockExperimentsInterface_SearchExperimentsAll_Call) Run(run func(ctx context.Context, request ml.SearchExperiments)) *MockExperimentsInterface_SearchExperimentsAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.SearchExperiments))
	})
	return _c
}

func (_c *MockExperimentsInterface_SearchExperimentsAll_Call) Return(_a0 []ml.Experiment, _a1 error) *MockExperimentsInterface_SearchExperimentsAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_SearchExperimentsAll_Call) RunAndReturn(run func(context.Context, ml.SearchExperiments) ([]ml.Experiment, error)) *MockExperimentsInterface_SearchExperimentsAll_Call {
	_c.Call.Return(run)
	return _c
}

// SearchRuns provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) SearchRuns(ctx context.Context, request ml.SearchRuns) listing.Iterator[ml.Run] {
	ret := _m.Called(ctx, request)

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

	var r0 listing.Iterator[ml.Run]
	if rf, ok := ret.Get(0).(func(context.Context, ml.SearchRuns) listing.Iterator[ml.Run]); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(listing.Iterator[ml.Run])
		}
	}

	return r0
}

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

// SearchRuns is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.SearchRuns
func (_e *MockExperimentsInterface_Expecter) SearchRuns(ctx interface{}, request interface{}) *MockExperimentsInterface_SearchRuns_Call {
	return &MockExperimentsInterface_SearchRuns_Call{Call: _e.mock.On("SearchRuns", ctx, request)}
}

func (_c *MockExperimentsInterface_SearchRuns_Call) Run(run func(ctx context.Context, request ml.SearchRuns)) *MockExperimentsInterface_SearchRuns_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.SearchRuns))
	})
	return _c
}

func (_c *MockExperimentsInterface_SearchRuns_Call) Return(_a0 listing.Iterator[ml.Run]) *MockExperimentsInterface_SearchRuns_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockExperimentsInterface_SearchRuns_Call) RunAndReturn(run func(context.Context, ml.SearchRuns) listing.Iterator[ml.Run]) *MockExperimentsInterface_SearchRuns_Call {
	_c.Call.Return(run)
	return _c
}

// SearchRunsAll provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) SearchRunsAll(ctx context.Context, request ml.SearchRuns) ([]ml.Run, error) {
	ret := _m.Called(ctx, request)

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

	var r0 []ml.Run
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.SearchRuns) ([]ml.Run, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.SearchRuns) []ml.Run); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]ml.Run)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.SearchRuns) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SearchRunsAll is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.SearchRuns
func (_e *MockExperimentsInterface_Expecter) SearchRunsAll(ctx interface{}, request interface{}) *MockExperimentsInterface_SearchRunsAll_Call {
	return &MockExperimentsInterface_SearchRunsAll_Call{Call: _e.mock.On("SearchRunsAll", ctx, request)}
}

func (_c *MockExperimentsInterface_SearchRunsAll_Call) Run(run func(ctx context.Context, request ml.SearchRuns)) *MockExperimentsInterface_SearchRunsAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.SearchRuns))
	})
	return _c
}

func (_c *MockExperimentsInterface_SearchRunsAll_Call) Return(_a0 []ml.Run, _a1 error) *MockExperimentsInterface_SearchRunsAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_SearchRunsAll_Call) RunAndReturn(run func(context.Context, ml.SearchRuns) ([]ml.Run, error)) *MockExperimentsInterface_SearchRunsAll_Call {
	_c.Call.Return(run)
	return _c
}

// SetExperimentTag provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) SetExperimentTag(ctx context.Context, request ml.SetExperimentTag) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.SetExperimentTag) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetExperimentTag is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.SetExperimentTag
func (_e *MockExperimentsInterface_Expecter) SetExperimentTag(ctx interface{}, request interface{}) *MockExperimentsInterface_SetExperimentTag_Call {
	return &MockExperimentsInterface_SetExperimentTag_Call{Call: _e.mock.On("SetExperimentTag", ctx, request)}
}

func (_c *MockExperimentsInterface_SetExperimentTag_Call) Run(run func(ctx context.Context, request ml.SetExperimentTag)) *MockExperimentsInterface_SetExperimentTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.SetExperimentTag))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_SetExperimentTag_Call) RunAndReturn(run func(context.Context, ml.SetExperimentTag) error) *MockExperimentsInterface_SetExperimentTag_Call {
	_c.Call.Return(run)
	return _c
}

// SetPermissions provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) SetPermissions(ctx context.Context, request ml.ExperimentPermissionsRequest) (*ml.ExperimentPermissions, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.ExperimentPermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.ExperimentPermissionsRequest) (*ml.ExperimentPermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.ExperimentPermissionsRequest) *ml.ExperimentPermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.ExperimentPermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.ExperimentPermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetPermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.ExperimentPermissionsRequest
func (_e *MockExperimentsInterface_Expecter) SetPermissions(ctx interface{}, request interface{}) *MockExperimentsInterface_SetPermissions_Call {
	return &MockExperimentsInterface_SetPermissions_Call{Call: _e.mock.On("SetPermissions", ctx, request)}
}

func (_c *MockExperimentsInterface_SetPermissions_Call) Run(run func(ctx context.Context, request ml.ExperimentPermissionsRequest)) *MockExperimentsInterface_SetPermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.ExperimentPermissionsRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_SetPermissions_Call) Return(_a0 *ml.ExperimentPermissions, _a1 error) *MockExperimentsInterface_SetPermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_SetPermissions_Call) RunAndReturn(run func(context.Context, ml.ExperimentPermissionsRequest) (*ml.ExperimentPermissions, error)) *MockExperimentsInterface_SetPermissions_Call {
	_c.Call.Return(run)
	return _c
}

// SetTag provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) SetTag(ctx context.Context, request ml.SetTag) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.SetTag) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetTag is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.SetTag
func (_e *MockExperimentsInterface_Expecter) SetTag(ctx interface{}, request interface{}) *MockExperimentsInterface_SetTag_Call {
	return &MockExperimentsInterface_SetTag_Call{Call: _e.mock.On("SetTag", ctx, request)}
}

func (_c *MockExperimentsInterface_SetTag_Call) Run(run func(ctx context.Context, request ml.SetTag)) *MockExperimentsInterface_SetTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.SetTag))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_SetTag_Call) RunAndReturn(run func(context.Context, ml.SetTag) error) *MockExperimentsInterface_SetTag_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateExperiment provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) UpdateExperiment(ctx context.Context, request ml.UpdateExperiment) error {
	ret := _m.Called(ctx, request)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.UpdateExperiment) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UpdateExperiment is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.UpdateExperiment
func (_e *MockExperimentsInterface_Expecter) UpdateExperiment(ctx interface{}, request interface{}) *MockExperimentsInterface_UpdateExperiment_Call {
	return &MockExperimentsInterface_UpdateExperiment_Call{Call: _e.mock.On("UpdateExperiment", ctx, request)}
}

func (_c *MockExperimentsInterface_UpdateExperiment_Call) Run(run func(ctx context.Context, request ml.UpdateExperiment)) *MockExperimentsInterface_UpdateExperiment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.UpdateExperiment))
	})
	return _c
}

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

func (_c *MockExperimentsInterface_UpdateExperiment_Call) RunAndReturn(run func(context.Context, ml.UpdateExperiment) error) *MockExperimentsInterface_UpdateExperiment_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePermissions provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) UpdatePermissions(ctx context.Context, request ml.ExperimentPermissionsRequest) (*ml.ExperimentPermissions, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.ExperimentPermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.ExperimentPermissionsRequest) (*ml.ExperimentPermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.ExperimentPermissionsRequest) *ml.ExperimentPermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.ExperimentPermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.ExperimentPermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdatePermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.ExperimentPermissionsRequest
func (_e *MockExperimentsInterface_Expecter) UpdatePermissions(ctx interface{}, request interface{}) *MockExperimentsInterface_UpdatePermissions_Call {
	return &MockExperimentsInterface_UpdatePermissions_Call{Call: _e.mock.On("UpdatePermissions", ctx, request)}
}

func (_c *MockExperimentsInterface_UpdatePermissions_Call) Run(run func(ctx context.Context, request ml.ExperimentPermissionsRequest)) *MockExperimentsInterface_UpdatePermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.ExperimentPermissionsRequest))
	})
	return _c
}

func (_c *MockExperimentsInterface_UpdatePermissions_Call) Return(_a0 *ml.ExperimentPermissions, _a1 error) *MockExperimentsInterface_UpdatePermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_UpdatePermissions_Call) RunAndReturn(run func(context.Context, ml.ExperimentPermissionsRequest) (*ml.ExperimentPermissions, error)) *MockExperimentsInterface_UpdatePermissions_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRun provides a mock function with given fields: ctx, request
func (_m *MockExperimentsInterface) UpdateRun(ctx context.Context, request ml.UpdateRun) (*ml.UpdateRunResponse, error) {
	ret := _m.Called(ctx, request)

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

	var r0 *ml.UpdateRunResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ml.UpdateRun) (*ml.UpdateRunResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ml.UpdateRun) *ml.UpdateRunResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ml.UpdateRunResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, ml.UpdateRun) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateRun is a helper method to define mock.On call
//   - ctx context.Context
//   - request ml.UpdateRun
func (_e *MockExperimentsInterface_Expecter) UpdateRun(ctx interface{}, request interface{}) *MockExperimentsInterface_UpdateRun_Call {
	return &MockExperimentsInterface_UpdateRun_Call{Call: _e.mock.On("UpdateRun", ctx, request)}
}

func (_c *MockExperimentsInterface_UpdateRun_Call) Run(run func(ctx context.Context, request ml.UpdateRun)) *MockExperimentsInterface_UpdateRun_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(ml.UpdateRun))
	})
	return _c
}

func (_c *MockExperimentsInterface_UpdateRun_Call) Return(_a0 *ml.UpdateRunResponse, _a1 error) *MockExperimentsInterface_UpdateRun_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockExperimentsInterface_UpdateRun_Call) RunAndReturn(run func(context.Context, ml.UpdateRun) (*ml.UpdateRunResponse, error)) *MockExperimentsInterface_UpdateRun_Call {
	_c.Call.Return(run)
	return _c
}

// WithImpl provides a mock function with given fields: impl
func (_m *MockExperimentsInterface) WithImpl(impl ml.ExperimentsService) ml.ExperimentsInterface {
	ret := _m.Called(impl)

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

	var r0 ml.ExperimentsInterface
	if rf, ok := ret.Get(0).(func(ml.ExperimentsService) ml.ExperimentsInterface); ok {
		r0 = rf(impl)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ml.ExperimentsInterface)
		}
	}

	return r0
}

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

// WithImpl is a helper method to define mock.On call
//   - impl ml.ExperimentsService
func (_e *MockExperimentsInterface_Expecter) WithImpl(impl interface{}) *MockExperimentsInterface_WithImpl_Call {
	return &MockExperimentsInterface_WithImpl_Call{Call: _e.mock.On("WithImpl", impl)}
}

func (_c *MockExperimentsInterface_WithImpl_Call) Run(run func(impl ml.ExperimentsService)) *MockExperimentsInterface_WithImpl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(ml.ExperimentsService))
	})
	return _c
}

func (_c *MockExperimentsInterface_WithImpl_Call) Return(_a0 ml.ExperimentsInterface) *MockExperimentsInterface_WithImpl_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockExperimentsInterface_WithImpl_Call) RunAndReturn(run func(ml.ExperimentsService) ml.ExperimentsInterface) *MockExperimentsInterface_WithImpl_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}