github.com/enbility/spine-go@v0.7.0/mocks/FeatureRemoteInterface.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"
)

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

type FeatureRemoteInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *FeatureRemoteInterface) EXPECT() *FeatureRemoteInterface_Expecter {
	return &FeatureRemoteInterface_Expecter{mock: &_m.Mock}
}

// Address provides a mock function with given fields:
func (_m *FeatureRemoteInterface) 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
}

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

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

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

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

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

// DataCopy provides a mock function with given fields: function
func (_m *FeatureRemoteInterface) 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
}

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

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

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

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

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

// Description provides a mock function with given fields:
func (_m *FeatureRemoteInterface) 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
}

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

func (_c *FeatureRemoteInterface_Device_Call) Return(_a0 api.DeviceRemoteInterface) *FeatureRemoteInterface_Device_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureRemoteInterface_Device_Call) RunAndReturn(run func() api.DeviceRemoteInterface) *FeatureRemoteInterface_Device_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *FeatureRemoteInterface_Entity_Call) Return(_a0 api.EntityRemoteInterface) *FeatureRemoteInterface_Entity_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FeatureRemoteInterface_Entity_Call) RunAndReturn(run func() api.EntityRemoteInterface) *FeatureRemoteInterface_Entity_Call {
	_c.Call.Return(run)
	return _c
}

// MaxResponseDelayDuration provides a mock function with given fields:
func (_m *FeatureRemoteInterface) MaxResponseDelayDuration() time.Duration {
	ret := _m.Called()

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

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

	return r0
}

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

// MaxResponseDelayDuration is a helper method to define mock.On call
func (_e *FeatureRemoteInterface_Expecter) MaxResponseDelayDuration() *FeatureRemoteInterface_MaxResponseDelayDuration_Call {
	return &FeatureRemoteInterface_MaxResponseDelayDuration_Call{Call: _e.mock.On("MaxResponseDelayDuration")}
}

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

func (_c *FeatureRemoteInterface_MaxResponseDelayDuration_Call) Return(_a0 time.Duration) *FeatureRemoteInterface_MaxResponseDelayDuration_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// Operations provides a mock function with given fields:
func (_m *FeatureRemoteInterface) 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
}

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

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

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

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

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

// Role provides a mock function with given fields:
func (_m *FeatureRemoteInterface) 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetMaxResponseDelay provides a mock function with given fields: delay
func (_m *FeatureRemoteInterface) SetMaxResponseDelay(delay *model.MaxResponseDelayType) {
	_m.Called(delay)
}

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

// SetMaxResponseDelay is a helper method to define mock.On call
//   - delay *model.MaxResponseDelayType
func (_e *FeatureRemoteInterface_Expecter) SetMaxResponseDelay(delay interface{}) *FeatureRemoteInterface_SetMaxResponseDelay_Call {
	return &FeatureRemoteInterface_SetMaxResponseDelay_Call{Call: _e.mock.On("SetMaxResponseDelay", delay)}
}

func (_c *FeatureRemoteInterface_SetMaxResponseDelay_Call) Run(run func(delay *model.MaxResponseDelayType)) *FeatureRemoteInterface_SetMaxResponseDelay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.MaxResponseDelayType))
	})
	return _c
}

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

func (_c *FeatureRemoteInterface_SetMaxResponseDelay_Call) RunAndReturn(run func(*model.MaxResponseDelayType)) *FeatureRemoteInterface_SetMaxResponseDelay_Call {
	_c.Call.Return(run)
	return _c
}

// SetOperations provides a mock function with given fields: functions
func (_m *FeatureRemoteInterface) SetOperations(functions []model.FunctionPropertyType) {
	_m.Called(functions)
}

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

// SetOperations is a helper method to define mock.On call
//   - functions []model.FunctionPropertyType
func (_e *FeatureRemoteInterface_Expecter) SetOperations(functions interface{}) *FeatureRemoteInterface_SetOperations_Call {
	return &FeatureRemoteInterface_SetOperations_Call{Call: _e.mock.On("SetOperations", functions)}
}

func (_c *FeatureRemoteInterface_SetOperations_Call) Run(run func(functions []model.FunctionPropertyType)) *FeatureRemoteInterface_SetOperations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]model.FunctionPropertyType))
	})
	return _c
}

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

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

// String provides a mock function with given fields:
func (_m *FeatureRemoteInterface) 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
}

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

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

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

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

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

// Type provides a mock function with given fields:
func (_m *FeatureRemoteInterface) 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
}

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

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

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

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

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

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

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

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

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

	return r0, r1
}

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

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

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

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

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

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

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

	return mock
}