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

package mocks

import (
	context "context"

	hostname "github.com/akash-network/provider/cluster/types/v1beta3/clients/hostname"
	ip "github.com/akash-network/provider/cluster/types/v1beta3/clients/ip"

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

	rest "github.com/akash-network/akash-api/go/provider/client"

	v1beta3 "github.com/akash-network/provider/cluster/types/v1beta3"

	v1beta4 "github.com/akash-network/akash-api/go/node/market/v1beta4"

	v2beta2 "github.com/akash-network/provider/pkg/apis/akash.network/v2beta2"
)

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

type ReadClient_Expecter struct {
	mock *mock.Mock
}

func (_m *ReadClient) EXPECT() *ReadClient_Expecter {
	return &ReadClient_Expecter{mock: &_m.Mock}
}

// AllHostnames provides a mock function with given fields: _a0
func (_m *ReadClient) AllHostnames(_a0 context.Context) ([]hostname.ActiveHostname, error) {
	ret := _m.Called(_a0)

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

	var r0 []hostname.ActiveHostname
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]hostname.ActiveHostname, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []hostname.ActiveHostname); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]hostname.ActiveHostname)
		}
	}

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

	return r0, r1
}

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

// AllHostnames is a helper method to define mock.On call
//   - _a0 context.Context
func (_e *ReadClient_Expecter) AllHostnames(_a0 interface{}) *ReadClient_AllHostnames_Call {
	return &ReadClient_AllHostnames_Call{Call: _e.mock.On("AllHostnames", _a0)}
}

func (_c *ReadClient_AllHostnames_Call) Run(run func(_a0 context.Context)) *ReadClient_AllHostnames_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *ReadClient_AllHostnames_Call) Return(_a0 []hostname.ActiveHostname, _a1 error) *ReadClient_AllHostnames_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_AllHostnames_Call) RunAndReturn(run func(context.Context) ([]hostname.ActiveHostname, error)) *ReadClient_AllHostnames_Call {
	_c.Call.Return(run)
	return _c
}

// ForwardedPortStatus provides a mock function with given fields: _a0, _a1
func (_m *ReadClient) ForwardedPortStatus(_a0 context.Context, _a1 v1beta4.LeaseID) (map[string][]rest.ForwardedPortStatus, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 map[string][]rest.ForwardedPortStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID) (map[string][]rest.ForwardedPortStatus, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID) map[string][]rest.ForwardedPortStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string][]rest.ForwardedPortStatus)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, v1beta4.LeaseID) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ForwardedPortStatus is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 v1beta4.LeaseID
func (_e *ReadClient_Expecter) ForwardedPortStatus(_a0 interface{}, _a1 interface{}) *ReadClient_ForwardedPortStatus_Call {
	return &ReadClient_ForwardedPortStatus_Call{Call: _e.mock.On("ForwardedPortStatus", _a0, _a1)}
}

func (_c *ReadClient_ForwardedPortStatus_Call) Run(run func(_a0 context.Context, _a1 v1beta4.LeaseID)) *ReadClient_ForwardedPortStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(v1beta4.LeaseID))
	})
	return _c
}

func (_c *ReadClient_ForwardedPortStatus_Call) Return(_a0 map[string][]rest.ForwardedPortStatus, _a1 error) *ReadClient_ForwardedPortStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_ForwardedPortStatus_Call) RunAndReturn(run func(context.Context, v1beta4.LeaseID) (map[string][]rest.ForwardedPortStatus, error)) *ReadClient_ForwardedPortStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeclaredIPs provides a mock function with given fields: ctx, leaseID
func (_m *ReadClient) GetDeclaredIPs(ctx context.Context, leaseID v1beta4.LeaseID) ([]v2beta2.ProviderLeasedIPSpec, error) {
	ret := _m.Called(ctx, leaseID)

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

	var r0 []v2beta2.ProviderLeasedIPSpec
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID) ([]v2beta2.ProviderLeasedIPSpec, error)); ok {
		return rf(ctx, leaseID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID) []v2beta2.ProviderLeasedIPSpec); ok {
		r0 = rf(ctx, leaseID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]v2beta2.ProviderLeasedIPSpec)
		}
	}

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

	return r0, r1
}

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

// GetDeclaredIPs is a helper method to define mock.On call
//   - ctx context.Context
//   - leaseID v1beta4.LeaseID
func (_e *ReadClient_Expecter) GetDeclaredIPs(ctx interface{}, leaseID interface{}) *ReadClient_GetDeclaredIPs_Call {
	return &ReadClient_GetDeclaredIPs_Call{Call: _e.mock.On("GetDeclaredIPs", ctx, leaseID)}
}

func (_c *ReadClient_GetDeclaredIPs_Call) Run(run func(ctx context.Context, leaseID v1beta4.LeaseID)) *ReadClient_GetDeclaredIPs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(v1beta4.LeaseID))
	})
	return _c
}

func (_c *ReadClient_GetDeclaredIPs_Call) Return(_a0 []v2beta2.ProviderLeasedIPSpec, _a1 error) *ReadClient_GetDeclaredIPs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_GetDeclaredIPs_Call) RunAndReturn(run func(context.Context, v1beta4.LeaseID) ([]v2beta2.ProviderLeasedIPSpec, error)) *ReadClient_GetDeclaredIPs_Call {
	_c.Call.Return(run)
	return _c
}

// GetHostnameDeploymentConnections provides a mock function with given fields: ctx
func (_m *ReadClient) GetHostnameDeploymentConnections(ctx context.Context) ([]hostname.LeaseIDConnection, error) {
	ret := _m.Called(ctx)

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

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

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

	return r0, r1
}

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

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

func (_c *ReadClient_GetHostnameDeploymentConnections_Call) Run(run func(ctx context.Context)) *ReadClient_GetHostnameDeploymentConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *ReadClient_GetHostnameDeploymentConnections_Call) Return(_a0 []hostname.LeaseIDConnection, _a1 error) *ReadClient_GetHostnameDeploymentConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_GetHostnameDeploymentConnections_Call) RunAndReturn(run func(context.Context) ([]hostname.LeaseIDConnection, error)) *ReadClient_GetHostnameDeploymentConnections_Call {
	_c.Call.Return(run)
	return _c
}

// GetManifestGroup provides a mock function with given fields: _a0, _a1
func (_m *ReadClient) GetManifestGroup(_a0 context.Context, _a1 v1beta4.LeaseID) (bool, v2beta2.ManifestGroup, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 bool
	var r1 v2beta2.ManifestGroup
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID) (bool, v2beta2.ManifestGroup, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID) bool); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, v1beta4.LeaseID) v2beta2.ManifestGroup); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Get(1).(v2beta2.ManifestGroup)
	}

	if rf, ok := ret.Get(2).(func(context.Context, v1beta4.LeaseID) error); ok {
		r2 = rf(_a0, _a1)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetManifestGroup is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 v1beta4.LeaseID
func (_e *ReadClient_Expecter) GetManifestGroup(_a0 interface{}, _a1 interface{}) *ReadClient_GetManifestGroup_Call {
	return &ReadClient_GetManifestGroup_Call{Call: _e.mock.On("GetManifestGroup", _a0, _a1)}
}

func (_c *ReadClient_GetManifestGroup_Call) Run(run func(_a0 context.Context, _a1 v1beta4.LeaseID)) *ReadClient_GetManifestGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(v1beta4.LeaseID))
	})
	return _c
}

func (_c *ReadClient_GetManifestGroup_Call) Return(_a0 bool, _a1 v2beta2.ManifestGroup, _a2 error) *ReadClient_GetManifestGroup_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *ReadClient_GetManifestGroup_Call) RunAndReturn(run func(context.Context, v1beta4.LeaseID) (bool, v2beta2.ManifestGroup, error)) *ReadClient_GetManifestGroup_Call {
	_c.Call.Return(run)
	return _c
}

// LeaseEvents provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *ReadClient) LeaseEvents(_a0 context.Context, _a1 v1beta4.LeaseID, _a2 string, _a3 bool) (v1beta3.EventsWatcher, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3)

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

	var r0 v1beta3.EventsWatcher
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID, string, bool) (v1beta3.EventsWatcher, error)); ok {
		return rf(_a0, _a1, _a2, _a3)
	}
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID, string, bool) v1beta3.EventsWatcher); ok {
		r0 = rf(_a0, _a1, _a2, _a3)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1beta3.EventsWatcher)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, v1beta4.LeaseID, string, bool) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LeaseEvents is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 v1beta4.LeaseID
//   - _a2 string
//   - _a3 bool
func (_e *ReadClient_Expecter) LeaseEvents(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 interface{}) *ReadClient_LeaseEvents_Call {
	return &ReadClient_LeaseEvents_Call{Call: _e.mock.On("LeaseEvents", _a0, _a1, _a2, _a3)}
}

func (_c *ReadClient_LeaseEvents_Call) Run(run func(_a0 context.Context, _a1 v1beta4.LeaseID, _a2 string, _a3 bool)) *ReadClient_LeaseEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(v1beta4.LeaseID), args[2].(string), args[3].(bool))
	})
	return _c
}

func (_c *ReadClient_LeaseEvents_Call) Return(_a0 v1beta3.EventsWatcher, _a1 error) *ReadClient_LeaseEvents_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_LeaseEvents_Call) RunAndReturn(run func(context.Context, v1beta4.LeaseID, string, bool) (v1beta3.EventsWatcher, error)) *ReadClient_LeaseEvents_Call {
	_c.Call.Return(run)
	return _c
}

// LeaseLogs provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4
func (_m *ReadClient) LeaseLogs(_a0 context.Context, _a1 v1beta4.LeaseID, _a2 string, _a3 bool, _a4 *int64) ([]*v1beta3.ServiceLog, error) {
	ret := _m.Called(_a0, _a1, _a2, _a3, _a4)

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

	var r0 []*v1beta3.ServiceLog
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID, string, bool, *int64) ([]*v1beta3.ServiceLog, error)); ok {
		return rf(_a0, _a1, _a2, _a3, _a4)
	}
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID, string, bool, *int64) []*v1beta3.ServiceLog); ok {
		r0 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*v1beta3.ServiceLog)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, v1beta4.LeaseID, string, bool, *int64) error); ok {
		r1 = rf(_a0, _a1, _a2, _a3, _a4)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LeaseLogs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 v1beta4.LeaseID
//   - _a2 string
//   - _a3 bool
//   - _a4 *int64
func (_e *ReadClient_Expecter) LeaseLogs(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 interface{}, _a4 interface{}) *ReadClient_LeaseLogs_Call {
	return &ReadClient_LeaseLogs_Call{Call: _e.mock.On("LeaseLogs", _a0, _a1, _a2, _a3, _a4)}
}

func (_c *ReadClient_LeaseLogs_Call) Run(run func(_a0 context.Context, _a1 v1beta4.LeaseID, _a2 string, _a3 bool, _a4 *int64)) *ReadClient_LeaseLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(v1beta4.LeaseID), args[2].(string), args[3].(bool), args[4].(*int64))
	})
	return _c
}

func (_c *ReadClient_LeaseLogs_Call) Return(_a0 []*v1beta3.ServiceLog, _a1 error) *ReadClient_LeaseLogs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_LeaseLogs_Call) RunAndReturn(run func(context.Context, v1beta4.LeaseID, string, bool, *int64) ([]*v1beta3.ServiceLog, error)) *ReadClient_LeaseLogs_Call {
	_c.Call.Return(run)
	return _c
}

// LeaseStatus provides a mock function with given fields: _a0, _a1
func (_m *ReadClient) LeaseStatus(_a0 context.Context, _a1 v1beta4.LeaseID) (map[string]*rest.ServiceStatus, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 map[string]*rest.ServiceStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID) (map[string]*rest.ServiceStatus, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID) map[string]*rest.ServiceStatus); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]*rest.ServiceStatus)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, v1beta4.LeaseID) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LeaseStatus is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 v1beta4.LeaseID
func (_e *ReadClient_Expecter) LeaseStatus(_a0 interface{}, _a1 interface{}) *ReadClient_LeaseStatus_Call {
	return &ReadClient_LeaseStatus_Call{Call: _e.mock.On("LeaseStatus", _a0, _a1)}
}

func (_c *ReadClient_LeaseStatus_Call) Run(run func(_a0 context.Context, _a1 v1beta4.LeaseID)) *ReadClient_LeaseStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(v1beta4.LeaseID))
	})
	return _c
}

func (_c *ReadClient_LeaseStatus_Call) Return(_a0 map[string]*rest.ServiceStatus, _a1 error) *ReadClient_LeaseStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_LeaseStatus_Call) RunAndReturn(run func(context.Context, v1beta4.LeaseID) (map[string]*rest.ServiceStatus, error)) *ReadClient_LeaseStatus_Call {
	_c.Call.Return(run)
	return _c
}

// ObserveHostnameState provides a mock function with given fields: ctx
func (_m *ReadClient) ObserveHostnameState(ctx context.Context) (<-chan hostname.ResourceEvent, error) {
	ret := _m.Called(ctx)

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

	var r0 <-chan hostname.ResourceEvent
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (<-chan hostname.ResourceEvent, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) <-chan hostname.ResourceEvent); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan hostname.ResourceEvent)
		}
	}

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

	return r0, r1
}

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

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

func (_c *ReadClient_ObserveHostnameState_Call) Run(run func(ctx context.Context)) *ReadClient_ObserveHostnameState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *ReadClient_ObserveHostnameState_Call) Return(_a0 <-chan hostname.ResourceEvent, _a1 error) *ReadClient_ObserveHostnameState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_ObserveHostnameState_Call) RunAndReturn(run func(context.Context) (<-chan hostname.ResourceEvent, error)) *ReadClient_ObserveHostnameState_Call {
	_c.Call.Return(run)
	return _c
}

// ObserveIPState provides a mock function with given fields: ctx
func (_m *ReadClient) ObserveIPState(ctx context.Context) (<-chan ip.ResourceEvent, error) {
	ret := _m.Called(ctx)

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

	var r0 <-chan ip.ResourceEvent
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (<-chan ip.ResourceEvent, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) <-chan ip.ResourceEvent); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan ip.ResourceEvent)
		}
	}

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

	return r0, r1
}

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

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

func (_c *ReadClient_ObserveIPState_Call) Run(run func(ctx context.Context)) *ReadClient_ObserveIPState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *ReadClient_ObserveIPState_Call) Return(_a0 <-chan ip.ResourceEvent, _a1 error) *ReadClient_ObserveIPState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_ObserveIPState_Call) RunAndReturn(run func(context.Context) (<-chan ip.ResourceEvent, error)) *ReadClient_ObserveIPState_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceStatus provides a mock function with given fields: _a0, _a1, _a2
func (_m *ReadClient) ServiceStatus(_a0 context.Context, _a1 v1beta4.LeaseID, _a2 string) (*rest.ServiceStatus, error) {
	ret := _m.Called(_a0, _a1, _a2)

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

	var r0 *rest.ServiceStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID, string) (*rest.ServiceStatus, error)); ok {
		return rf(_a0, _a1, _a2)
	}
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID, string) *rest.ServiceStatus); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rest.ServiceStatus)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, v1beta4.LeaseID, string) error); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ServiceStatus is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 v1beta4.LeaseID
//   - _a2 string
func (_e *ReadClient_Expecter) ServiceStatus(_a0 interface{}, _a1 interface{}, _a2 interface{}) *ReadClient_ServiceStatus_Call {
	return &ReadClient_ServiceStatus_Call{Call: _e.mock.On("ServiceStatus", _a0, _a1, _a2)}
}

func (_c *ReadClient_ServiceStatus_Call) Run(run func(_a0 context.Context, _a1 v1beta4.LeaseID, _a2 string)) *ReadClient_ServiceStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(v1beta4.LeaseID), args[2].(string))
	})
	return _c
}

func (_c *ReadClient_ServiceStatus_Call) Return(_a0 *rest.ServiceStatus, _a1 error) *ReadClient_ServiceStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ReadClient_ServiceStatus_Call) RunAndReturn(run func(context.Context, v1beta4.LeaseID, string) (*rest.ServiceStatus, error)) *ReadClient_ServiceStatus_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}
