github.com/enbility/spine-go@v0.7.0/mocks/FeatureLocalInterface.go

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

package mocks

import (
	api "github.com/enbility/spine-go/api"
	mock "github.com/stretchr/testify/mock"

	model "github.com/enbility/spine-go/model"

	time "time"
)

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

type FeatureLocalInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *FeatureLocalInterface) EXPECT() *FeatureLocalInterface_Expecter {
	return &FeatureLocalInterface_Expecter{mock: &_m.Mock}
}

// AddFunctionType provides a mock function with given fields: function, read, write
func (_m *FeatureLocalInterface) AddFunctionType(function model.FunctionType, read bool, write bool) {
	_m.Called(function, read, write)
}

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

// AddFunctionType is a helper method to define mock.On call
//   - function model.FunctionType
//   - read bool
//   - write bool
func (_e *FeatureLocalInterface_Expecter) AddFunctionType(function interface{}, read interface{}, write interface{}) *FeatureLocalInterface_AddFunctionType_Call {
	return &FeatureLocalInterface_AddFunctionType_Call{Call: _e.mock.On("AddFunctionType", function, read, write)}
}

func (_c *FeatureLocalInterface_AddFunctionType_Call) Run(run func(function model.FunctionType, read bool, write bool)) *FeatureLocalInterface_AddFunctionType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.FunctionType), args[1].(bool), args[2].(bool))
	})
	return _c
}

func (_c *FeatureLocalInterface_AddFunctionType_Call) Return() *FeatureLocalInterface_AddFunctionType_Call {
	_c.Call.Return()
	return _c
}

func (_c *FeatureLocalInterface_AddFunctionType_Call) RunAndReturn(run func(model.FunctionType, bool, bool)) *FeatureLocalInterface_AddFunctionType_Call {
	_c.Call.Return(run)
	return _c
}

// AddResponseCallback provides a mock function with given fields: msgCounterReference, function
func (_m *FeatureLocalInterface) AddResponseCallback(msgCounterReference model.MsgCounterType, function func(api.ResponseMessage)) error {
	ret := _m.Called(msgCounterReference, function)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(model.MsgCounterType, func(api.ResponseMessage)) error); ok {
		r0 = rf(msgCounterReference, function)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddResponseCallback is a helper method to define mock.On call
//   - msgCounterReference model.MsgCounterType
//   - function func(api.ResponseMessage)
func (_e *FeatureLocalInterface_Expecter) AddResponseCallback(msgCounterReference interface{}, function interface{}) *FeatureLocalInterface_AddResponseCallback_Call {
	return &FeatureLocalInterface_AddResponseCallback_Call{Call: _e.mock.On("AddResponseCallback", msgCounterReference, function)}
}

func (_c *FeatureLocalInterface_AddResponseCallback_Call) Run(run func(msgCounterReference model.MsgCounterType, function func(api.ResponseMessage))) *FeatureLocalInterface_AddResponseCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.MsgCounterType), args[1].(func(api.ResponseMessage)))
	})
	return _c
}

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

func (_c *FeatureLocalInterface_AddResponseCallback_Call) RunAndReturn(run func(model.MsgCounterType, func(api.ResponseMessage)) error) *FeatureLocalInterface_AddResponseCallback_Call {
	_c.Call.Return(run)
	return _c
}

// AddResultCallback provides a mock function with given fields: function
func (_m *FeatureLocalInterface) AddResultCallback(function func(api.ResponseMessage)) {
	_m.Called(function)
}

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

// AddResultCallback is a helper method to define mock.On call
//   - function func(api.ResponseMessage)
func (_e *FeatureLocalInterface_Expecter) AddResultCallback(function interface{}) *FeatureLocalInterface_AddResultCallback_Call {
	return &FeatureLocalInterface_AddResultCallback_Call{Call: _e.mock.On("AddResultCallback", function)}
}

func (_c *FeatureLocalInterface_AddResultCallback_Call) Run(run func(function func(api.ResponseMessage))) *FeatureLocalInterface_AddResultCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(api.ResponseMessage)))
	})
	return _c
}

func (_c *FeatureLocalInterface_AddResultCallback_Call) Return() *FeatureLocalInterface_AddResultCallback_Call {
	_c.Call.Return()
	return _c
}

func (_c *FeatureLocalInterface_AddResultCallback_Call) RunAndReturn(run func(func(api.ResponseMessage))) *FeatureLocalInterface_AddResultCallback_Call {
	_c.Call.Return(run)
	return _c
}

// AddWriteApprovalCallback provides a mock function with given fields: function
func (_m *FeatureLocalInterface) AddWriteApprovalCallback(function api.WriteApprovalCallbackFunc) error {
	ret := _m.Called(function)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(api.WriteApprovalCallbackFunc) error); ok {
		r0 = rf(function)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddWriteApprovalCallback is a helper method to define mock.On call
//   - function api.WriteApprovalCallbackFunc
func (_e *FeatureLocalInterface_Expecter) AddWriteApprovalCallback(function interface{}) *FeatureLocalInterface_AddWriteApprovalCallback_Call {
	return &FeatureLocalInterface_AddWriteApprovalCallback_Call{Call: _e.mock.On("AddWriteApprovalCallback", function)}
}

func (_c *FeatureLocalInterface_AddWriteApprovalCallback_Call) Run(run func(function api.WriteApprovalCallbackFunc)) *FeatureLocalInterface_AddWriteApprovalCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(api.WriteApprovalCallbackFunc))
	})
	return _c
}

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

func (_c *FeatureLocalInterface_AddWriteApprovalCallback_Call) RunAndReturn(run func(api.WriteApprovalCallbackFunc) error) *FeatureLocalInterface_AddWriteApprovalCallback_Call {
	_c.Call.Return(run)
	return _c
}

// Address provides a mock function with given fields:
func (_m *FeatureLocalInterface) Address() *model.FeatureAddressType {
	ret := _m.Called()

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

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

	return r0
}

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

// Address is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) Address() *FeatureLocalInterface_Address_Call {
	return &FeatureLocalInterface_Address_Call{Call: _e.mock.On("Address")}
}

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

func (_c *FeatureLocalInterface_Address_Call) Return(_a0 *model.FeatureAddressType) *FeatureLocalInterface_Address_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Address_Call) RunAndReturn(run func() *model.FeatureAddressType) *FeatureLocalInterface_Address_Call {
	_c.Call.Return(run)
	return _c
}

// ApproveOrDenyWrite provides a mock function with given fields: msg, err
func (_m *FeatureLocalInterface) ApproveOrDenyWrite(msg *api.Message, err model.ErrorType) {
	_m.Called(msg, err)
}

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

// ApproveOrDenyWrite is a helper method to define mock.On call
//   - msg *api.Message
//   - err model.ErrorType
func (_e *FeatureLocalInterface_Expecter) ApproveOrDenyWrite(msg interface{}, err interface{}) *FeatureLocalInterface_ApproveOrDenyWrite_Call {
	return &FeatureLocalInterface_ApproveOrDenyWrite_Call{Call: _e.mock.On("ApproveOrDenyWrite", msg, err)}
}

func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) Run(run func(msg *api.Message, err model.ErrorType)) *FeatureLocalInterface_ApproveOrDenyWrite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*api.Message), args[1].(model.ErrorType))
	})
	return _c
}

func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) Return() *FeatureLocalInterface_ApproveOrDenyWrite_Call {
	_c.Call.Return()
	return _c
}

func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) RunAndReturn(run func(*api.Message, model.ErrorType)) *FeatureLocalInterface_ApproveOrDenyWrite_Call {
	_c.Call.Return(run)
	return _c
}

// BindToRemote provides a mock function with given fields: remoteAddress
func (_m *FeatureLocalInterface) BindToRemote(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) {
	ret := _m.Called(remoteAddress)

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

	var r0 *model.MsgCounterType
	var r1 *model.ErrorType
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok {
		return rf(remoteAddress)
	}
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok {
		r0 = rf(remoteAddress)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MsgCounterType)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok {
		r1 = rf(remoteAddress)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*model.ErrorType)
		}
	}

	return r0, r1
}

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

// BindToRemote is a helper method to define mock.On call
//   - remoteAddress *model.FeatureAddressType
func (_e *FeatureLocalInterface_Expecter) BindToRemote(remoteAddress interface{}) *FeatureLocalInterface_BindToRemote_Call {
	return &FeatureLocalInterface_BindToRemote_Call{Call: _e.mock.On("BindToRemote", remoteAddress)}
}

func (_c *FeatureLocalInterface_BindToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_BindToRemote_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.FeatureAddressType))
	})
	return _c
}

func (_c *FeatureLocalInterface_BindToRemote_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_BindToRemote_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FeatureLocalInterface_BindToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_BindToRemote_Call {
	_c.Call.Return(run)
	return _c
}

// CleanRemoteDeviceCaches provides a mock function with given fields: remoteAddress
func (_m *FeatureLocalInterface) CleanRemoteDeviceCaches(remoteAddress *model.DeviceAddressType) {
	_m.Called(remoteAddress)
}

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

// CleanRemoteDeviceCaches is a helper method to define mock.On call
//   - remoteAddress *model.DeviceAddressType
func (_e *FeatureLocalInterface_Expecter) CleanRemoteDeviceCaches(remoteAddress interface{}) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call {
	return &FeatureLocalInterface_CleanRemoteDeviceCaches_Call{Call: _e.mock.On("CleanRemoteDeviceCaches", remoteAddress)}
}

func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) Run(run func(remoteAddress *model.DeviceAddressType)) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.DeviceAddressType))
	})
	return _c
}

func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) Return() *FeatureLocalInterface_CleanRemoteDeviceCaches_Call {
	_c.Call.Return()
	return _c
}

func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) RunAndReturn(run func(*model.DeviceAddressType)) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call {
	_c.Call.Return(run)
	return _c
}

// CleanRemoteEntityCaches provides a mock function with given fields: remoteAddress
func (_m *FeatureLocalInterface) CleanRemoteEntityCaches(remoteAddress *model.EntityAddressType) {
	_m.Called(remoteAddress)
}

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

// CleanRemoteEntityCaches is a helper method to define mock.On call
//   - remoteAddress *model.EntityAddressType
func (_e *FeatureLocalInterface_Expecter) CleanRemoteEntityCaches(remoteAddress interface{}) *FeatureLocalInterface_CleanRemoteEntityCaches_Call {
	return &FeatureLocalInterface_CleanRemoteEntityCaches_Call{Call: _e.mock.On("CleanRemoteEntityCaches", remoteAddress)}
}

func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) Run(run func(remoteAddress *model.EntityAddressType)) *FeatureLocalInterface_CleanRemoteEntityCaches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.EntityAddressType))
	})
	return _c
}

func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) Return() *FeatureLocalInterface_CleanRemoteEntityCaches_Call {
	_c.Call.Return()
	return _c
}

func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) RunAndReturn(run func(*model.EntityAddressType)) *FeatureLocalInterface_CleanRemoteEntityCaches_Call {
	_c.Call.Return(run)
	return _c
}

// CleanWriteApprovalCaches provides a mock function with given fields: ski
func (_m *FeatureLocalInterface) CleanWriteApprovalCaches(ski string) {
	_m.Called(ski)
}

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

// CleanWriteApprovalCaches is a helper method to define mock.On call
//   - ski string
func (_e *FeatureLocalInterface_Expecter) CleanWriteApprovalCaches(ski interface{}) *FeatureLocalInterface_CleanWriteApprovalCaches_Call {
	return &FeatureLocalInterface_CleanWriteApprovalCaches_Call{Call: _e.mock.On("CleanWriteApprovalCaches", ski)}
}

func (_c *FeatureLocalInterface_CleanWriteApprovalCaches_Call) Run(run func(ski string)) *FeatureLocalInterface_CleanWriteApprovalCaches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *FeatureLocalInterface_CleanWriteApprovalCaches_Call) Return() *FeatureLocalInterface_CleanWriteApprovalCaches_Call {
	_c.Call.Return()
	return _c
}

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

// DataCopy provides a mock function with given fields: function
func (_m *FeatureLocalInterface) DataCopy(function model.FunctionType) interface{} {
	ret := _m.Called(function)

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

	var r0 interface{}
	if rf, ok := ret.Get(0).(func(model.FunctionType) interface{}); ok {
		r0 = rf(function)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	return r0
}

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

// DataCopy is a helper method to define mock.On call
//   - function model.FunctionType
func (_e *FeatureLocalInterface_Expecter) DataCopy(function interface{}) *FeatureLocalInterface_DataCopy_Call {
	return &FeatureLocalInterface_DataCopy_Call{Call: _e.mock.On("DataCopy", function)}
}

func (_c *FeatureLocalInterface_DataCopy_Call) Run(run func(function model.FunctionType)) *FeatureLocalInterface_DataCopy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.FunctionType))
	})
	return _c
}

func (_c *FeatureLocalInterface_DataCopy_Call) Return(_a0 interface{}) *FeatureLocalInterface_DataCopy_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_DataCopy_Call) RunAndReturn(run func(model.FunctionType) interface{}) *FeatureLocalInterface_DataCopy_Call {
	_c.Call.Return(run)
	return _c
}

// Description provides a mock function with given fields:
func (_m *FeatureLocalInterface) Description() *model.DescriptionType {
	ret := _m.Called()

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

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

	return r0
}

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

// Description is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) Description() *FeatureLocalInterface_Description_Call {
	return &FeatureLocalInterface_Description_Call{Call: _e.mock.On("Description")}
}

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

func (_c *FeatureLocalInterface_Description_Call) Return(_a0 *model.DescriptionType) *FeatureLocalInterface_Description_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Description_Call) RunAndReturn(run func() *model.DescriptionType) *FeatureLocalInterface_Description_Call {
	_c.Call.Return(run)
	return _c
}

// Device provides a mock function with given fields:
func (_m *FeatureLocalInterface) Device() api.DeviceLocalInterface {
	ret := _m.Called()

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

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

	return r0
}

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

// Device is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) Device() *FeatureLocalInterface_Device_Call {
	return &FeatureLocalInterface_Device_Call{Call: _e.mock.On("Device")}
}

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

func (_c *FeatureLocalInterface_Device_Call) Return(_a0 api.DeviceLocalInterface) *FeatureLocalInterface_Device_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Device_Call) RunAndReturn(run func() api.DeviceLocalInterface) *FeatureLocalInterface_Device_Call {
	_c.Call.Return(run)
	return _c
}

// Entity provides a mock function with given fields:
func (_m *FeatureLocalInterface) Entity() api.EntityLocalInterface {
	ret := _m.Called()

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

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

	return r0
}

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

// Entity is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) Entity() *FeatureLocalInterface_Entity_Call {
	return &FeatureLocalInterface_Entity_Call{Call: _e.mock.On("Entity")}
}

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

func (_c *FeatureLocalInterface_Entity_Call) Return(_a0 api.EntityLocalInterface) *FeatureLocalInterface_Entity_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Entity_Call) RunAndReturn(run func() api.EntityLocalInterface) *FeatureLocalInterface_Entity_Call {
	_c.Call.Return(run)
	return _c
}

// Functions provides a mock function with given fields:
func (_m *FeatureLocalInterface) Functions() []model.FunctionType {
	ret := _m.Called()

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

	var r0 []model.FunctionType
	if rf, ok := ret.Get(0).(func() []model.FunctionType); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]model.FunctionType)
		}
	}

	return r0
}

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

// Functions is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) Functions() *FeatureLocalInterface_Functions_Call {
	return &FeatureLocalInterface_Functions_Call{Call: _e.mock.On("Functions")}
}

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

func (_c *FeatureLocalInterface_Functions_Call) Return(_a0 []model.FunctionType) *FeatureLocalInterface_Functions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Functions_Call) RunAndReturn(run func() []model.FunctionType) *FeatureLocalInterface_Functions_Call {
	_c.Call.Return(run)
	return _c
}

// HandleMessage provides a mock function with given fields: message
func (_m *FeatureLocalInterface) HandleMessage(message *api.Message) *model.ErrorType {
	ret := _m.Called(message)

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

	var r0 *model.ErrorType
	if rf, ok := ret.Get(0).(func(*api.Message) *model.ErrorType); ok {
		r0 = rf(message)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.ErrorType)
		}
	}

	return r0
}

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

// HandleMessage is a helper method to define mock.On call
//   - message *api.Message
func (_e *FeatureLocalInterface_Expecter) HandleMessage(message interface{}) *FeatureLocalInterface_HandleMessage_Call {
	return &FeatureLocalInterface_HandleMessage_Call{Call: _e.mock.On("HandleMessage", message)}
}

func (_c *FeatureLocalInterface_HandleMessage_Call) Run(run func(message *api.Message)) *FeatureLocalInterface_HandleMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*api.Message))
	})
	return _c
}

func (_c *FeatureLocalInterface_HandleMessage_Call) Return(_a0 *model.ErrorType) *FeatureLocalInterface_HandleMessage_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_HandleMessage_Call) RunAndReturn(run func(*api.Message) *model.ErrorType) *FeatureLocalInterface_HandleMessage_Call {
	_c.Call.Return(run)
	return _c
}

// HasBindingToRemote provides a mock function with given fields: remoteAddress
func (_m *FeatureLocalInterface) HasBindingToRemote(remoteAddress *model.FeatureAddressType) bool {
	ret := _m.Called(remoteAddress)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) bool); ok {
		r0 = rf(remoteAddress)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// HasBindingToRemote is a helper method to define mock.On call
//   - remoteAddress *model.FeatureAddressType
func (_e *FeatureLocalInterface_Expecter) HasBindingToRemote(remoteAddress interface{}) *FeatureLocalInterface_HasBindingToRemote_Call {
	return &FeatureLocalInterface_HasBindingToRemote_Call{Call: _e.mock.On("HasBindingToRemote", remoteAddress)}
}

func (_c *FeatureLocalInterface_HasBindingToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_HasBindingToRemote_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.FeatureAddressType))
	})
	return _c
}

func (_c *FeatureLocalInterface_HasBindingToRemote_Call) Return(_a0 bool) *FeatureLocalInterface_HasBindingToRemote_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_HasBindingToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) bool) *FeatureLocalInterface_HasBindingToRemote_Call {
	_c.Call.Return(run)
	return _c
}

// HasSubscriptionToRemote provides a mock function with given fields: remoteAddress
func (_m *FeatureLocalInterface) HasSubscriptionToRemote(remoteAddress *model.FeatureAddressType) bool {
	ret := _m.Called(remoteAddress)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) bool); ok {
		r0 = rf(remoteAddress)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// HasSubscriptionToRemote is a helper method to define mock.On call
//   - remoteAddress *model.FeatureAddressType
func (_e *FeatureLocalInterface_Expecter) HasSubscriptionToRemote(remoteAddress interface{}) *FeatureLocalInterface_HasSubscriptionToRemote_Call {
	return &FeatureLocalInterface_HasSubscriptionToRemote_Call{Call: _e.mock.On("HasSubscriptionToRemote", remoteAddress)}
}

func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_HasSubscriptionToRemote_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.FeatureAddressType))
	})
	return _c
}

func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) Return(_a0 bool) *FeatureLocalInterface_HasSubscriptionToRemote_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) bool) *FeatureLocalInterface_HasSubscriptionToRemote_Call {
	_c.Call.Return(run)
	return _c
}

// Information provides a mock function with given fields:
func (_m *FeatureLocalInterface) Information() *model.NodeManagementDetailedDiscoveryFeatureInformationType {
	ret := _m.Called()

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

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

	return r0
}

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

// Information is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) Information() *FeatureLocalInterface_Information_Call {
	return &FeatureLocalInterface_Information_Call{Call: _e.mock.On("Information")}
}

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

func (_c *FeatureLocalInterface_Information_Call) Return(_a0 *model.NodeManagementDetailedDiscoveryFeatureInformationType) *FeatureLocalInterface_Information_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Information_Call) RunAndReturn(run func() *model.NodeManagementDetailedDiscoveryFeatureInformationType) *FeatureLocalInterface_Information_Call {
	_c.Call.Return(run)
	return _c
}

// Operations provides a mock function with given fields:
func (_m *FeatureLocalInterface) Operations() map[model.FunctionType]api.OperationsInterface {
	ret := _m.Called()

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

	var r0 map[model.FunctionType]api.OperationsInterface
	if rf, ok := ret.Get(0).(func() map[model.FunctionType]api.OperationsInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[model.FunctionType]api.OperationsInterface)
		}
	}

	return r0
}

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

// Operations is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) Operations() *FeatureLocalInterface_Operations_Call {
	return &FeatureLocalInterface_Operations_Call{Call: _e.mock.On("Operations")}
}

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

func (_c *FeatureLocalInterface_Operations_Call) Return(_a0 map[model.FunctionType]api.OperationsInterface) *FeatureLocalInterface_Operations_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Operations_Call) RunAndReturn(run func() map[model.FunctionType]api.OperationsInterface) *FeatureLocalInterface_Operations_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllRemoteBindings provides a mock function with given fields:
func (_m *FeatureLocalInterface) RemoveAllRemoteBindings() {
	_m.Called()
}

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

// RemoveAllRemoteBindings is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) RemoveAllRemoteBindings() *FeatureLocalInterface_RemoveAllRemoteBindings_Call {
	return &FeatureLocalInterface_RemoveAllRemoteBindings_Call{Call: _e.mock.On("RemoveAllRemoteBindings")}
}

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

func (_c *FeatureLocalInterface_RemoveAllRemoteBindings_Call) Return() *FeatureLocalInterface_RemoveAllRemoteBindings_Call {
	_c.Call.Return()
	return _c
}

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

// RemoveAllRemoteSubscriptions provides a mock function with given fields:
func (_m *FeatureLocalInterface) RemoveAllRemoteSubscriptions() {
	_m.Called()
}

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

// RemoveAllRemoteSubscriptions is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) RemoveAllRemoteSubscriptions() *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call {
	return &FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call{Call: _e.mock.On("RemoveAllRemoteSubscriptions")}
}

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

func (_c *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call) Return() *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call {
	_c.Call.Return()
	return _c
}

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

// RemoveRemoteBinding provides a mock function with given fields: remoteAddress
func (_m *FeatureLocalInterface) RemoveRemoteBinding(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) {
	ret := _m.Called(remoteAddress)

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

	var r0 *model.MsgCounterType
	var r1 *model.ErrorType
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok {
		return rf(remoteAddress)
	}
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok {
		r0 = rf(remoteAddress)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MsgCounterType)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok {
		r1 = rf(remoteAddress)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*model.ErrorType)
		}
	}

	return r0, r1
}

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

// RemoveRemoteBinding is a helper method to define mock.On call
//   - remoteAddress *model.FeatureAddressType
func (_e *FeatureLocalInterface_Expecter) RemoveRemoteBinding(remoteAddress interface{}) *FeatureLocalInterface_RemoveRemoteBinding_Call {
	return &FeatureLocalInterface_RemoveRemoteBinding_Call{Call: _e.mock.On("RemoveRemoteBinding", remoteAddress)}
}

func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_RemoveRemoteBinding_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.FeatureAddressType))
	})
	return _c
}

func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RemoveRemoteBinding_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RemoveRemoteBinding_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveRemoteSubscription provides a mock function with given fields: remoteAddress
func (_m *FeatureLocalInterface) RemoveRemoteSubscription(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) {
	ret := _m.Called(remoteAddress)

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

	var r0 *model.MsgCounterType
	var r1 *model.ErrorType
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok {
		return rf(remoteAddress)
	}
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok {
		r0 = rf(remoteAddress)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MsgCounterType)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok {
		r1 = rf(remoteAddress)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*model.ErrorType)
		}
	}

	return r0, r1
}

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

// RemoveRemoteSubscription is a helper method to define mock.On call
//   - remoteAddress *model.FeatureAddressType
func (_e *FeatureLocalInterface_Expecter) RemoveRemoteSubscription(remoteAddress interface{}) *FeatureLocalInterface_RemoveRemoteSubscription_Call {
	return &FeatureLocalInterface_RemoveRemoteSubscription_Call{Call: _e.mock.On("RemoveRemoteSubscription", remoteAddress)}
}

func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_RemoveRemoteSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.FeatureAddressType))
	})
	return _c
}

func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RemoveRemoteSubscription_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RemoveRemoteSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// RequestRemoteData provides a mock function with given fields: function, selector, elements, destination
func (_m *FeatureLocalInterface) RequestRemoteData(function model.FunctionType, selector interface{}, elements interface{}, destination api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType) {
	ret := _m.Called(function, selector, elements, destination)

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

	var r0 *model.MsgCounterType
	var r1 *model.ErrorType
	if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType)); ok {
		return rf(function, selector, elements, destination)
	}
	if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) *model.MsgCounterType); ok {
		r0 = rf(function, selector, elements, destination)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MsgCounterType)
		}
	}

	if rf, ok := ret.Get(1).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) *model.ErrorType); ok {
		r1 = rf(function, selector, elements, destination)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*model.ErrorType)
		}
	}

	return r0, r1
}

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

// RequestRemoteData is a helper method to define mock.On call
//   - function model.FunctionType
//   - selector interface{}
//   - elements interface{}
//   - destination api.FeatureRemoteInterface
func (_e *FeatureLocalInterface_Expecter) RequestRemoteData(function interface{}, selector interface{}, elements interface{}, destination interface{}) *FeatureLocalInterface_RequestRemoteData_Call {
	return &FeatureLocalInterface_RequestRemoteData_Call{Call: _e.mock.On("RequestRemoteData", function, selector, elements, destination)}
}

func (_c *FeatureLocalInterface_RequestRemoteData_Call) Run(run func(function model.FunctionType, selector interface{}, elements interface{}, destination api.FeatureRemoteInterface)) *FeatureLocalInterface_RequestRemoteData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.FunctionType), args[1].(interface{}), args[2].(interface{}), args[3].(api.FeatureRemoteInterface))
	})
	return _c
}

func (_c *FeatureLocalInterface_RequestRemoteData_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RequestRemoteData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FeatureLocalInterface_RequestRemoteData_Call) RunAndReturn(run func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RequestRemoteData_Call {
	_c.Call.Return(run)
	return _c
}

// RequestRemoteDataBySenderAddress provides a mock function with given fields: cmd, sender, destinationSki, destinationAddress, maxDelay
func (_m *FeatureLocalInterface) RequestRemoteDataBySenderAddress(cmd model.CmdType, sender api.SenderInterface, destinationSki string, destinationAddress *model.FeatureAddressType, maxDelay time.Duration) (*model.MsgCounterType, *model.ErrorType) {
	ret := _m.Called(cmd, sender, destinationSki, destinationAddress, maxDelay)

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

	var r0 *model.MsgCounterType
	var r1 *model.ErrorType
	if rf, ok := ret.Get(0).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) (*model.MsgCounterType, *model.ErrorType)); ok {
		return rf(cmd, sender, destinationSki, destinationAddress, maxDelay)
	}
	if rf, ok := ret.Get(0).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) *model.MsgCounterType); ok {
		r0 = rf(cmd, sender, destinationSki, destinationAddress, maxDelay)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MsgCounterType)
		}
	}

	if rf, ok := ret.Get(1).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) *model.ErrorType); ok {
		r1 = rf(cmd, sender, destinationSki, destinationAddress, maxDelay)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*model.ErrorType)
		}
	}

	return r0, r1
}

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

// RequestRemoteDataBySenderAddress is a helper method to define mock.On call
//   - cmd model.CmdType
//   - sender api.SenderInterface
//   - destinationSki string
//   - destinationAddress *model.FeatureAddressType
//   - maxDelay time.Duration
func (_e *FeatureLocalInterface_Expecter) RequestRemoteDataBySenderAddress(cmd interface{}, sender interface{}, destinationSki interface{}, destinationAddress interface{}, maxDelay interface{}) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call {
	return &FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call{Call: _e.mock.On("RequestRemoteDataBySenderAddress", cmd, sender, destinationSki, destinationAddress, maxDelay)}
}

func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) Run(run func(cmd model.CmdType, sender api.SenderInterface, destinationSki string, destinationAddress *model.FeatureAddressType, maxDelay time.Duration)) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.CmdType), args[1].(api.SenderInterface), args[2].(string), args[3].(*model.FeatureAddressType), args[4].(time.Duration))
	})
	return _c
}

func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) RunAndReturn(run func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call {
	_c.Call.Return(run)
	return _c
}

// Role provides a mock function with given fields:
func (_m *FeatureLocalInterface) Role() model.RoleType {
	ret := _m.Called()

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

	var r0 model.RoleType
	if rf, ok := ret.Get(0).(func() model.RoleType); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(model.RoleType)
	}

	return r0
}

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

// Role is a helper method to define mock.On call
func (_e *FeatureLocalInterface_Expecter) Role() *FeatureLocalInterface_Role_Call {
	return &FeatureLocalInterface_Role_Call{Call: _e.mock.On("Role")}
}

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

func (_c *FeatureLocalInterface_Role_Call) Return(_a0 model.RoleType) *FeatureLocalInterface_Role_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Role_Call) RunAndReturn(run func() model.RoleType) *FeatureLocalInterface_Role_Call {
	_c.Call.Return(run)
	return _c
}

// SetData provides a mock function with given fields: function, data
func (_m *FeatureLocalInterface) SetData(function model.FunctionType, data interface{}) {
	_m.Called(function, data)
}

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

// SetData is a helper method to define mock.On call
//   - function model.FunctionType
//   - data interface{}
func (_e *FeatureLocalInterface_Expecter) SetData(function interface{}, data interface{}) *FeatureLocalInterface_SetData_Call {
	return &FeatureLocalInterface_SetData_Call{Call: _e.mock.On("SetData", function, data)}
}

func (_c *FeatureLocalInterface_SetData_Call) Run(run func(function model.FunctionType, data interface{})) *FeatureLocalInterface_SetData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.FunctionType), args[1].(interface{}))
	})
	return _c
}

func (_c *FeatureLocalInterface_SetData_Call) Return() *FeatureLocalInterface_SetData_Call {
	_c.Call.Return()
	return _c
}

func (_c *FeatureLocalInterface_SetData_Call) RunAndReturn(run func(model.FunctionType, interface{})) *FeatureLocalInterface_SetData_Call {
	_c.Call.Return(run)
	return _c
}

// SetDescription provides a mock function with given fields: desc
func (_m *FeatureLocalInterface) SetDescription(desc *model.DescriptionType) {
	_m.Called(desc)
}

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

// SetDescription is a helper method to define mock.On call
//   - desc *model.DescriptionType
func (_e *FeatureLocalInterface_Expecter) SetDescription(desc interface{}) *FeatureLocalInterface_SetDescription_Call {
	return &FeatureLocalInterface_SetDescription_Call{Call: _e.mock.On("SetDescription", desc)}
}

func (_c *FeatureLocalInterface_SetDescription_Call) Run(run func(desc *model.DescriptionType)) *FeatureLocalInterface_SetDescription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.DescriptionType))
	})
	return _c
}

func (_c *FeatureLocalInterface_SetDescription_Call) Return() *FeatureLocalInterface_SetDescription_Call {
	_c.Call.Return()
	return _c
}

func (_c *FeatureLocalInterface_SetDescription_Call) RunAndReturn(run func(*model.DescriptionType)) *FeatureLocalInterface_SetDescription_Call {
	_c.Call.Return(run)
	return _c
}

// SetDescriptionString provides a mock function with given fields: s
func (_m *FeatureLocalInterface) SetDescriptionString(s string) {
	_m.Called(s)
}

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

// SetDescriptionString is a helper method to define mock.On call
//   - s string
func (_e *FeatureLocalInterface_Expecter) SetDescriptionString(s interface{}) *FeatureLocalInterface_SetDescriptionString_Call {
	return &FeatureLocalInterface_SetDescriptionString_Call{Call: _e.mock.On("SetDescriptionString", s)}
}

func (_c *FeatureLocalInterface_SetDescriptionString_Call) Run(run func(s string)) *FeatureLocalInterface_SetDescriptionString_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *FeatureLocalInterface_SetDescriptionString_Call) Return() *FeatureLocalInterface_SetDescriptionString_Call {
	_c.Call.Return()
	return _c
}

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

// SetWriteApprovalTimeout provides a mock function with given fields: duration
func (_m *FeatureLocalInterface) SetWriteApprovalTimeout(duration time.Duration) {
	_m.Called(duration)
}

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

// SetWriteApprovalTimeout is a helper method to define mock.On call
//   - duration time.Duration
func (_e *FeatureLocalInterface_Expecter) SetWriteApprovalTimeout(duration interface{}) *FeatureLocalInterface_SetWriteApprovalTimeout_Call {
	return &FeatureLocalInterface_SetWriteApprovalTimeout_Call{Call: _e.mock.On("SetWriteApprovalTimeout", duration)}
}

func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) Run(run func(duration time.Duration)) *FeatureLocalInterface_SetWriteApprovalTimeout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(time.Duration))
	})
	return _c
}

func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) Return() *FeatureLocalInterface_SetWriteApprovalTimeout_Call {
	_c.Call.Return()
	return _c
}

func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) RunAndReturn(run func(time.Duration)) *FeatureLocalInterface_SetWriteApprovalTimeout_Call {
	_c.Call.Return(run)
	return _c
}

// String provides a mock function with given fields:
func (_m *FeatureLocalInterface) String() string {
	ret := _m.Called()

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

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

	return r0
}

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

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

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

func (_c *FeatureLocalInterface_String_Call) Return(_a0 string) *FeatureLocalInterface_String_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// SubscribeToRemote provides a mock function with given fields: remoteAddress
func (_m *FeatureLocalInterface) SubscribeToRemote(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) {
	ret := _m.Called(remoteAddress)

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

	var r0 *model.MsgCounterType
	var r1 *model.ErrorType
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok {
		return rf(remoteAddress)
	}
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok {
		r0 = rf(remoteAddress)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MsgCounterType)
		}
	}

	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok {
		r1 = rf(remoteAddress)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*model.ErrorType)
		}
	}

	return r0, r1
}

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

// SubscribeToRemote is a helper method to define mock.On call
//   - remoteAddress *model.FeatureAddressType
func (_e *FeatureLocalInterface_Expecter) SubscribeToRemote(remoteAddress interface{}) *FeatureLocalInterface_SubscribeToRemote_Call {
	return &FeatureLocalInterface_SubscribeToRemote_Call{Call: _e.mock.On("SubscribeToRemote", remoteAddress)}
}

func (_c *FeatureLocalInterface_SubscribeToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_SubscribeToRemote_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.FeatureAddressType))
	})
	return _c
}

func (_c *FeatureLocalInterface_SubscribeToRemote_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_SubscribeToRemote_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FeatureLocalInterface_SubscribeToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_SubscribeToRemote_Call {
	_c.Call.Return(run)
	return _c
}

// Type provides a mock function with given fields:
func (_m *FeatureLocalInterface) Type() model.FeatureTypeType {
	ret := _m.Called()

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

	var r0 model.FeatureTypeType
	if rf, ok := ret.Get(0).(func() model.FeatureTypeType); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(model.FeatureTypeType)
	}

	return r0
}

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

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

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

func (_c *FeatureLocalInterface_Type_Call) Return(_a0 model.FeatureTypeType) *FeatureLocalInterface_Type_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_Type_Call) RunAndReturn(run func() model.FeatureTypeType) *FeatureLocalInterface_Type_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateData provides a mock function with given fields: function, data, filterPartial, filterDelete
func (_m *FeatureLocalInterface) UpdateData(function model.FunctionType, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType) *model.ErrorType {
	ret := _m.Called(function, data, filterPartial, filterDelete)

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

	var r0 *model.ErrorType
	if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType); ok {
		r0 = rf(function, data, filterPartial, filterDelete)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.ErrorType)
		}
	}

	return r0
}

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

// UpdateData is a helper method to define mock.On call
//   - function model.FunctionType
//   - data interface{}
//   - filterPartial *model.FilterType
//   - filterDelete *model.FilterType
func (_e *FeatureLocalInterface_Expecter) UpdateData(function interface{}, data interface{}, filterPartial interface{}, filterDelete interface{}) *FeatureLocalInterface_UpdateData_Call {
	return &FeatureLocalInterface_UpdateData_Call{Call: _e.mock.On("UpdateData", function, data, filterPartial, filterDelete)}
}

func (_c *FeatureLocalInterface_UpdateData_Call) Run(run func(function model.FunctionType, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType)) *FeatureLocalInterface_UpdateData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.FunctionType), args[1].(interface{}), args[2].(*model.FilterType), args[3].(*model.FilterType))
	})
	return _c
}

func (_c *FeatureLocalInterface_UpdateData_Call) Return(_a0 *model.ErrorType) *FeatureLocalInterface_UpdateData_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureLocalInterface_UpdateData_Call) RunAndReturn(run func(model.FunctionType, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType) *FeatureLocalInterface_UpdateData_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}