EntityLocalInterface.go

// Code generated by mockery v2.42.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"
)

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

type EntityLocalInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *EntityLocalInterface) EXPECT() *EntityLocalInterface_Expecter {
	return &EntityLocalInterface_Expecter{mock: &_m.Mock}
}

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

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

// AddFeature is a helper method to define mock.On call
//   - f api.FeatureLocalInterface
func (_e *EntityLocalInterface_Expecter) AddFeature(f interface{}) *EntityLocalInterface_AddFeature_Call {
	return &EntityLocalInterface_AddFeature_Call{Call: _e.mock.On("AddFeature", f)}
}

func (_c *EntityLocalInterface_AddFeature_Call) Run(run func(f api.FeatureLocalInterface)) *EntityLocalInterface_AddFeature_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(api.FeatureLocalInterface))
	})
	return _c
}

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

func (_c *EntityLocalInterface_AddFeature_Call) RunAndReturn(run func(api.FeatureLocalInterface)) *EntityLocalInterface_AddFeature_Call {
	_c.Call.Return(run)
	return _c
}

// AddUseCaseSupport provides a mock function with given fields: actor, useCaseName, useCaseVersion, useCaseDocumemtSubRevision, useCaseAvailable, scenarios
func (_m *EntityLocalInterface) AddUseCaseSupport(actor model.UseCaseActorType, useCaseName model.UseCaseNameType, useCaseVersion model.SpecificationVersionType, useCaseDocumemtSubRevision string, useCaseAvailable bool, scenarios []model.UseCaseScenarioSupportType) {
	_m.Called(actor, useCaseName, useCaseVersion, useCaseDocumemtSubRevision, useCaseAvailable, scenarios)
}

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

// AddUseCaseSupport is a helper method to define mock.On call
//   - actor model.UseCaseActorType
//   - useCaseName model.UseCaseNameType
//   - useCaseVersion model.SpecificationVersionType
//   - useCaseDocumemtSubRevision string
//   - useCaseAvailable bool
//   - scenarios []model.UseCaseScenarioSupportType
func (_e *EntityLocalInterface_Expecter) AddUseCaseSupport(actor interface{}, useCaseName interface{}, useCaseVersion interface{}, useCaseDocumemtSubRevision interface{}, useCaseAvailable interface{}, scenarios interface{}) *EntityLocalInterface_AddUseCaseSupport_Call {
	return &EntityLocalInterface_AddUseCaseSupport_Call{Call: _e.mock.On("AddUseCaseSupport", actor, useCaseName, useCaseVersion, useCaseDocumemtSubRevision, useCaseAvailable, scenarios)}
}

func (_c *EntityLocalInterface_AddUseCaseSupport_Call) Run(run func(actor model.UseCaseActorType, useCaseName model.UseCaseNameType, useCaseVersion model.SpecificationVersionType, useCaseDocumemtSubRevision string, useCaseAvailable bool, scenarios []model.UseCaseScenarioSupportType)) *EntityLocalInterface_AddUseCaseSupport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.UseCaseActorType), args[1].(model.UseCaseNameType), args[2].(model.SpecificationVersionType), args[3].(string), args[4].(bool), args[5].([]model.UseCaseScenarioSupportType))
	})
	return _c
}

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

func (_c *EntityLocalInterface_AddUseCaseSupport_Call) RunAndReturn(run func(model.UseCaseActorType, model.UseCaseNameType, model.SpecificationVersionType, string, bool, []model.UseCaseScenarioSupportType)) *EntityLocalInterface_AddUseCaseSupport_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *EntityLocalInterface_Address_Call) Return(_a0 *model.EntityAddressType) *EntityLocalInterface_Address_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// EntityType provides a mock function with given fields:
func (_m *EntityLocalInterface) EntityType() model.EntityTypeType {
	ret := _m.Called()

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

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

	return r0
}

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

// EntityType is a helper method to define mock.On call
func (_e *EntityLocalInterface_Expecter) EntityType() *EntityLocalInterface_EntityType_Call {
	return &EntityLocalInterface_EntityType_Call{Call: _e.mock.On("EntityType")}
}

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

func (_c *EntityLocalInterface_EntityType_Call) Return(_a0 model.EntityTypeType) *EntityLocalInterface_EntityType_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EntityLocalInterface_EntityType_Call) RunAndReturn(run func() model.EntityTypeType) *EntityLocalInterface_EntityType_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// FeatureOfAddress is a helper method to define mock.On call
//   - addressFeature *model.AddressFeatureType
func (_e *EntityLocalInterface_Expecter) FeatureOfAddress(addressFeature interface{}) *EntityLocalInterface_FeatureOfAddress_Call {
	return &EntityLocalInterface_FeatureOfAddress_Call{Call: _e.mock.On("FeatureOfAddress", addressFeature)}
}

func (_c *EntityLocalInterface_FeatureOfAddress_Call) Run(run func(addressFeature *model.AddressFeatureType)) *EntityLocalInterface_FeatureOfAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.AddressFeatureType))
	})
	return _c
}

func (_c *EntityLocalInterface_FeatureOfAddress_Call) Return(_a0 api.FeatureLocalInterface) *EntityLocalInterface_FeatureOfAddress_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EntityLocalInterface_FeatureOfAddress_Call) RunAndReturn(run func(*model.AddressFeatureType) api.FeatureLocalInterface) *EntityLocalInterface_FeatureOfAddress_Call {
	_c.Call.Return(run)
	return _c
}

// FeatureOfTypeAndRole provides a mock function with given fields: featureType, role
func (_m *EntityLocalInterface) FeatureOfTypeAndRole(featureType model.FeatureTypeType, role model.RoleType) api.FeatureLocalInterface {
	ret := _m.Called(featureType, role)

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

	var r0 api.FeatureLocalInterface
	if rf, ok := ret.Get(0).(func(model.FeatureTypeType, model.RoleType) api.FeatureLocalInterface); ok {
		r0 = rf(featureType, role)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.FeatureLocalInterface)
		}
	}

	return r0
}

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

// FeatureOfTypeAndRole is a helper method to define mock.On call
//   - featureType model.FeatureTypeType
//   - role model.RoleType
func (_e *EntityLocalInterface_Expecter) FeatureOfTypeAndRole(featureType interface{}, role interface{}) *EntityLocalInterface_FeatureOfTypeAndRole_Call {
	return &EntityLocalInterface_FeatureOfTypeAndRole_Call{Call: _e.mock.On("FeatureOfTypeAndRole", featureType, role)}
}

func (_c *EntityLocalInterface_FeatureOfTypeAndRole_Call) Run(run func(featureType model.FeatureTypeType, role model.RoleType)) *EntityLocalInterface_FeatureOfTypeAndRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.FeatureTypeType), args[1].(model.RoleType))
	})
	return _c
}

func (_c *EntityLocalInterface_FeatureOfTypeAndRole_Call) Return(_a0 api.FeatureLocalInterface) *EntityLocalInterface_FeatureOfTypeAndRole_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EntityLocalInterface_FeatureOfTypeAndRole_Call) RunAndReturn(run func(model.FeatureTypeType, model.RoleType) api.FeatureLocalInterface) *EntityLocalInterface_FeatureOfTypeAndRole_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// Features is a helper method to define mock.On call
func (_e *EntityLocalInterface_Expecter) Features() *EntityLocalInterface_Features_Call {
	return &EntityLocalInterface_Features_Call{Call: _e.mock.On("Features")}
}

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

func (_c *EntityLocalInterface_Features_Call) Return(_a0 []api.FeatureLocalInterface) *EntityLocalInterface_Features_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EntityLocalInterface_Features_Call) RunAndReturn(run func() []api.FeatureLocalInterface) *EntityLocalInterface_Features_Call {
	_c.Call.Return(run)
	return _c
}

// GetOrAddFeature provides a mock function with given fields: featureType, role
func (_m *EntityLocalInterface) GetOrAddFeature(featureType model.FeatureTypeType, role model.RoleType) api.FeatureLocalInterface {
	ret := _m.Called(featureType, role)

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

	var r0 api.FeatureLocalInterface
	if rf, ok := ret.Get(0).(func(model.FeatureTypeType, model.RoleType) api.FeatureLocalInterface); ok {
		r0 = rf(featureType, role)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.FeatureLocalInterface)
		}
	}

	return r0
}

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

// GetOrAddFeature is a helper method to define mock.On call
//   - featureType model.FeatureTypeType
//   - role model.RoleType
func (_e *EntityLocalInterface_Expecter) GetOrAddFeature(featureType interface{}, role interface{}) *EntityLocalInterface_GetOrAddFeature_Call {
	return &EntityLocalInterface_GetOrAddFeature_Call{Call: _e.mock.On("GetOrAddFeature", featureType, role)}
}

func (_c *EntityLocalInterface_GetOrAddFeature_Call) Run(run func(featureType model.FeatureTypeType, role model.RoleType)) *EntityLocalInterface_GetOrAddFeature_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.FeatureTypeType), args[1].(model.RoleType))
	})
	return _c
}

func (_c *EntityLocalInterface_GetOrAddFeature_Call) Return(_a0 api.FeatureLocalInterface) *EntityLocalInterface_GetOrAddFeature_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EntityLocalInterface_GetOrAddFeature_Call) RunAndReturn(run func(model.FeatureTypeType, model.RoleType) api.FeatureLocalInterface) *EntityLocalInterface_GetOrAddFeature_Call {
	_c.Call.Return(run)
	return _c
}

// HasUseCaseSupport provides a mock function with given fields: actor, useCaseName
func (_m *EntityLocalInterface) HasUseCaseSupport(actor model.UseCaseActorType, useCaseName model.UseCaseNameType) bool {
	ret := _m.Called(actor, useCaseName)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(model.UseCaseActorType, model.UseCaseNameType) bool); ok {
		r0 = rf(actor, useCaseName)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// HasUseCaseSupport is a helper method to define mock.On call
//   - actor model.UseCaseActorType
//   - useCaseName model.UseCaseNameType
func (_e *EntityLocalInterface_Expecter) HasUseCaseSupport(actor interface{}, useCaseName interface{}) *EntityLocalInterface_HasUseCaseSupport_Call {
	return &EntityLocalInterface_HasUseCaseSupport_Call{Call: _e.mock.On("HasUseCaseSupport", actor, useCaseName)}
}

func (_c *EntityLocalInterface_HasUseCaseSupport_Call) Run(run func(actor model.UseCaseActorType, useCaseName model.UseCaseNameType)) *EntityLocalInterface_HasUseCaseSupport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.UseCaseActorType), args[1].(model.UseCaseNameType))
	})
	return _c
}

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

func (_c *EntityLocalInterface_HasUseCaseSupport_Call) RunAndReturn(run func(model.UseCaseActorType, model.UseCaseNameType) bool) *EntityLocalInterface_HasUseCaseSupport_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *EntityLocalInterface_Information_Call) Return(_a0 *model.NodeManagementDetailedDiscoveryEntityInformationType) *EntityLocalInterface_Information_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *EntityLocalInterface_Information_Call) RunAndReturn(run func() *model.NodeManagementDetailedDiscoveryEntityInformationType) *EntityLocalInterface_Information_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// NextFeatureId is a helper method to define mock.On call
func (_e *EntityLocalInterface_Expecter) NextFeatureId() *EntityLocalInterface_NextFeatureId_Call {
	return &EntityLocalInterface_NextFeatureId_Call{Call: _e.mock.On("NextFeatureId")}
}

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

func (_c *EntityLocalInterface_NextFeatureId_Call) Return(_a0 uint) *EntityLocalInterface_NextFeatureId_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

// RemoveAllBindings is a helper method to define mock.On call
func (_e *EntityLocalInterface_Expecter) RemoveAllBindings() *EntityLocalInterface_RemoveAllBindings_Call {
	return &EntityLocalInterface_RemoveAllBindings_Call{Call: _e.mock.On("RemoveAllBindings")}
}

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

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

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

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

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

// RemoveAllSubscriptions is a helper method to define mock.On call
func (_e *EntityLocalInterface_Expecter) RemoveAllSubscriptions() *EntityLocalInterface_RemoveAllSubscriptions_Call {
	return &EntityLocalInterface_RemoveAllSubscriptions_Call{Call: _e.mock.On("RemoveAllSubscriptions")}
}

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

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

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

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

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

// RemoveAllUseCaseSupports is a helper method to define mock.On call
func (_e *EntityLocalInterface_Expecter) RemoveAllUseCaseSupports() *EntityLocalInterface_RemoveAllUseCaseSupports_Call {
	return &EntityLocalInterface_RemoveAllUseCaseSupports_Call{Call: _e.mock.On("RemoveAllUseCaseSupports")}
}

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

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

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

// RemoveUseCaseSupport provides a mock function with given fields: actor, useCaseName
func (_m *EntityLocalInterface) RemoveUseCaseSupport(actor model.UseCaseActorType, useCaseName model.UseCaseNameType) {
	_m.Called(actor, useCaseName)
}

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

// RemoveUseCaseSupport is a helper method to define mock.On call
//   - actor model.UseCaseActorType
//   - useCaseName model.UseCaseNameType
func (_e *EntityLocalInterface_Expecter) RemoveUseCaseSupport(actor interface{}, useCaseName interface{}) *EntityLocalInterface_RemoveUseCaseSupport_Call {
	return &EntityLocalInterface_RemoveUseCaseSupport_Call{Call: _e.mock.On("RemoveUseCaseSupport", actor, useCaseName)}
}

func (_c *EntityLocalInterface_RemoveUseCaseSupport_Call) Run(run func(actor model.UseCaseActorType, useCaseName model.UseCaseNameType)) *EntityLocalInterface_RemoveUseCaseSupport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.UseCaseActorType), args[1].(model.UseCaseNameType))
	})
	return _c
}

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

func (_c *EntityLocalInterface_RemoveUseCaseSupport_Call) RunAndReturn(run func(model.UseCaseActorType, model.UseCaseNameType)) *EntityLocalInterface_RemoveUseCaseSupport_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

// SetUseCaseAvailability provides a mock function with given fields: actor, useCaseName, available
func (_m *EntityLocalInterface) SetUseCaseAvailability(actor model.UseCaseActorType, useCaseName model.UseCaseNameType, available bool) {
	_m.Called(actor, useCaseName, available)
}

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

// SetUseCaseAvailability is a helper method to define mock.On call
//   - actor model.UseCaseActorType
//   - useCaseName model.UseCaseNameType
//   - available bool
func (_e *EntityLocalInterface_Expecter) SetUseCaseAvailability(actor interface{}, useCaseName interface{}, available interface{}) *EntityLocalInterface_SetUseCaseAvailability_Call {
	return &EntityLocalInterface_SetUseCaseAvailability_Call{Call: _e.mock.On("SetUseCaseAvailability", actor, useCaseName, available)}
}

func (_c *EntityLocalInterface_SetUseCaseAvailability_Call) Run(run func(actor model.UseCaseActorType, useCaseName model.UseCaseNameType, available bool)) *EntityLocalInterface_SetUseCaseAvailability_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.UseCaseActorType), args[1].(model.UseCaseNameType), args[2].(bool))
	})
	return _c
}

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

func (_c *EntityLocalInterface_SetUseCaseAvailability_Call) RunAndReturn(run func(model.UseCaseActorType, model.UseCaseNameType, bool)) *EntityLocalInterface_SetUseCaseAvailability_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}