// Code generated by MockGen. DO NOT EDIT.
// Source: git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/pbehavior (interfaces: Service,ModelProvider,EventManager,Store,EntityTypeResolver,ComputedEntityTypeResolver,TypeComputer,InheritedServicePbhResolver)
//
// Generated by this command:
//
//	mockgen -destination=../../../mocks/lib/canopsis/pbehavior/pbehavior.go git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/pbehavior Service,ModelProvider,EventManager,Store,EntityTypeResolver,ComputedEntityTypeResolver,TypeComputer,InheritedServicePbhResolver
//

// Package mock_pbehavior is a generated GoMock package.
package mock_pbehavior

import (
	context "context"
	reflect "reflect"
	time "time"

	datetime "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/datetime"
	pbehavior "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/pbehavior"
	types "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/types"
	timespan "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/timespan"
	gomock "go.uber.org/mock/gomock"
)

// MockService is a mock of Service interface.
type MockService struct {
	ctrl     *gomock.Controller
	recorder *MockServiceMockRecorder
	isgomock struct{}
}

// MockServiceMockRecorder is the mock recorder for MockService.
type MockServiceMockRecorder struct {
	mock *MockService
}

// NewMockService creates a new mock instance.
func NewMockService(ctrl *gomock.Controller) *MockService {
	mock := &MockService{ctrl: ctrl}
	mock.recorder = &MockServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockService) EXPECT() *MockServiceMockRecorder {
	return m.recorder
}

// Compute mocks base method.
func (m *MockService) Compute(ctx context.Context, span timespan.Span, location *time.Location) (pbehavior.ComputedEntityTypeResolver, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Compute", ctx, span, location)
	ret0, _ := ret[0].(pbehavior.ComputedEntityTypeResolver)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Compute indicates an expected call of Compute.
func (mr *MockServiceMockRecorder) Compute(ctx, span, location any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compute", reflect.TypeOf((*MockService)(nil).Compute), ctx, span, location)
}

// Recompute mocks base method.
func (m *MockService) Recompute(ctx context.Context, location *time.Location) (pbehavior.ComputedEntityTypeResolver, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recompute", ctx, location)
	ret0, _ := ret[0].(pbehavior.ComputedEntityTypeResolver)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recompute indicates an expected call of Recompute.
func (mr *MockServiceMockRecorder) Recompute(ctx, location any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recompute", reflect.TypeOf((*MockService)(nil).Recompute), ctx, location)
}

// RecomputeByIds mocks base method.
func (m *MockService) RecomputeByIds(ctx context.Context, pbehaviorIds []string, location *time.Location) (pbehavior.ComputedEntityTypeResolver, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecomputeByIds", ctx, pbehaviorIds, location)
	ret0, _ := ret[0].(pbehavior.ComputedEntityTypeResolver)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RecomputeByIds indicates an expected call of RecomputeByIds.
func (mr *MockServiceMockRecorder) RecomputeByIds(ctx, pbehaviorIds, location any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecomputeByIds", reflect.TypeOf((*MockService)(nil).RecomputeByIds), ctx, pbehaviorIds, location)
}

// MockModelProvider is a mock of ModelProvider interface.
type MockModelProvider struct {
	ctrl     *gomock.Controller
	recorder *MockModelProviderMockRecorder
	isgomock struct{}
}

// MockModelProviderMockRecorder is the mock recorder for MockModelProvider.
type MockModelProviderMockRecorder struct {
	mock *MockModelProvider
}

// NewMockModelProvider creates a new mock instance.
func NewMockModelProvider(ctrl *gomock.Controller) *MockModelProvider {
	mock := &MockModelProvider{ctrl: ctrl}
	mock.recorder = &MockModelProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockModelProvider) EXPECT() *MockModelProviderMockRecorder {
	return m.recorder
}

// GetEnabledPbehaviors mocks base method.
func (m *MockModelProvider) GetEnabledPbehaviors(ctx context.Context, span timespan.Span) (map[string]pbehavior.PBehavior, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEnabledPbehaviors", ctx, span)
	ret0, _ := ret[0].(map[string]pbehavior.PBehavior)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEnabledPbehaviors indicates an expected call of GetEnabledPbehaviors.
func (mr *MockModelProviderMockRecorder) GetEnabledPbehaviors(ctx, span any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEnabledPbehaviors", reflect.TypeOf((*MockModelProvider)(nil).GetEnabledPbehaviors), ctx, span)
}

// GetEnabledPbehaviorsByIds mocks base method.
func (m *MockModelProvider) GetEnabledPbehaviorsByIds(ctx context.Context, ids []string, span timespan.Span) (map[string]pbehavior.PBehavior, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEnabledPbehaviorsByIds", ctx, ids, span)
	ret0, _ := ret[0].(map[string]pbehavior.PBehavior)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEnabledPbehaviorsByIds indicates an expected call of GetEnabledPbehaviorsByIds.
func (mr *MockModelProviderMockRecorder) GetEnabledPbehaviorsByIds(ctx, ids, span any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEnabledPbehaviorsByIds", reflect.TypeOf((*MockModelProvider)(nil).GetEnabledPbehaviorsByIds), ctx, ids, span)
}

// GetExceptions mocks base method.
func (m *MockModelProvider) GetExceptions(ctx context.Context) (map[string]pbehavior.Exception, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExceptions", ctx)
	ret0, _ := ret[0].(map[string]pbehavior.Exception)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExceptions indicates an expected call of GetExceptions.
func (mr *MockModelProviderMockRecorder) GetExceptions(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExceptions", reflect.TypeOf((*MockModelProvider)(nil).GetExceptions), ctx)
}

// GetReasons mocks base method.
func (m *MockModelProvider) GetReasons(ctx context.Context) (map[string]pbehavior.Reason, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReasons", ctx)
	ret0, _ := ret[0].(map[string]pbehavior.Reason)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReasons indicates an expected call of GetReasons.
func (mr *MockModelProviderMockRecorder) GetReasons(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReasons", reflect.TypeOf((*MockModelProvider)(nil).GetReasons), ctx)
}

// GetTypes mocks base method.
func (m *MockModelProvider) GetTypes(ctx context.Context) (map[string]pbehavior.Type, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTypes", ctx)
	ret0, _ := ret[0].(map[string]pbehavior.Type)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTypes indicates an expected call of GetTypes.
func (mr *MockModelProviderMockRecorder) GetTypes(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTypes", reflect.TypeOf((*MockModelProvider)(nil).GetTypes), ctx)
}

// MockEventManager is a mock of EventManager interface.
type MockEventManager struct {
	ctrl     *gomock.Controller
	recorder *MockEventManagerMockRecorder
	isgomock struct{}
}

// MockEventManagerMockRecorder is the mock recorder for MockEventManager.
type MockEventManagerMockRecorder struct {
	mock *MockEventManager
}

// NewMockEventManager creates a new mock instance.
func NewMockEventManager(ctrl *gomock.Controller) *MockEventManager {
	mock := &MockEventManager{ctrl: ctrl}
	mock.recorder = &MockEventManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockEventManager) EXPECT() *MockEventManagerMockRecorder {
	return m.recorder
}

// GetEvent mocks base method.
func (m *MockEventManager) GetEvent(arg0 pbehavior.ResolveResult, arg1 types.Entity, arg2 datetime.CpsTime) (types.Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEvent", arg0, arg1, arg2)
	ret0, _ := ret[0].(types.Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEvent indicates an expected call of GetEvent.
func (mr *MockEventManagerMockRecorder) GetEvent(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEvent", reflect.TypeOf((*MockEventManager)(nil).GetEvent), arg0, arg1, arg2)
}

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStore) EXPECT() *MockStoreMockRecorder {
	return m.recorder
}

// DelComputedPbehavior mocks base method.
func (m *MockStore) DelComputedPbehavior(ctx context.Context, pbhID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DelComputedPbehavior", ctx, pbhID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DelComputedPbehavior indicates an expected call of DelComputedPbehavior.
func (mr *MockStoreMockRecorder) DelComputedPbehavior(ctx, pbhID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelComputedPbehavior", reflect.TypeOf((*MockStore)(nil).DelComputedPbehavior), ctx, pbhID)
}

// GetComputed mocks base method.
func (m *MockStore) GetComputed(ctx context.Context) (pbehavior.ComputeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputed", ctx)
	ret0, _ := ret[0].(pbehavior.ComputeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetComputed indicates an expected call of GetComputed.
func (mr *MockStoreMockRecorder) GetComputed(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputed", reflect.TypeOf((*MockStore)(nil).GetComputed), ctx)
}

// GetComputedByIDs mocks base method.
func (m *MockStore) GetComputedByIDs(ctx context.Context, pbehaviorIDs []string) (pbehavior.ComputeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputedByIDs", ctx, pbehaviorIDs)
	ret0, _ := ret[0].(pbehavior.ComputeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetComputedByIDs indicates an expected call of GetComputedByIDs.
func (mr *MockStoreMockRecorder) GetComputedByIDs(ctx, pbehaviorIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputedByIDs", reflect.TypeOf((*MockStore)(nil).GetComputedByIDs), ctx, pbehaviorIDs)
}

// GetInheritedServicesPbhResolveResult mocks base method.
func (m *MockStore) GetInheritedServicesPbhResolveResult(ctx context.Context) (pbehavior.InheritedServicesPbhResolveResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInheritedServicesPbhResolveResult", ctx)
	ret0, _ := ret[0].(pbehavior.InheritedServicesPbhResolveResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInheritedServicesPbhResolveResult indicates an expected call of GetInheritedServicesPbhResolveResult.
func (mr *MockStoreMockRecorder) GetInheritedServicesPbhResolveResult(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInheritedServicesPbhResolveResult", reflect.TypeOf((*MockStore)(nil).GetInheritedServicesPbhResolveResult), ctx)
}

// GetSpan mocks base method.
func (m *MockStore) GetSpan(ctx context.Context) (timespan.Span, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSpan", ctx)
	ret0, _ := ret[0].(timespan.Span)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSpan indicates an expected call of GetSpan.
func (mr *MockStoreMockRecorder) GetSpan(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpan", reflect.TypeOf((*MockStore)(nil).GetSpan), ctx)
}

// SetComputed mocks base method.
func (m *MockStore) SetComputed(ctx context.Context, computed pbehavior.ComputeResult) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetComputed", ctx, computed)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetComputed indicates an expected call of SetComputed.
func (mr *MockStoreMockRecorder) SetComputed(ctx, computed any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetComputed", reflect.TypeOf((*MockStore)(nil).SetComputed), ctx, computed)
}

// SetComputedPbehavior mocks base method.
func (m *MockStore) SetComputedPbehavior(ctx context.Context, pbhID string, computed pbehavior.ComputedPbehavior) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetComputedPbehavior", ctx, pbhID, computed)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetComputedPbehavior indicates an expected call of SetComputedPbehavior.
func (mr *MockStoreMockRecorder) SetComputedPbehavior(ctx, pbhID, computed any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetComputedPbehavior", reflect.TypeOf((*MockStore)(nil).SetComputedPbehavior), ctx, pbhID, computed)
}

// SetInheritedServicesPbhResolveResult mocks base method.
func (m *MockStore) SetInheritedServicesPbhResolveResult(ctx context.Context, inheritedServicePbhResult pbehavior.InheritedServicesPbhResolveResult) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInheritedServicesPbhResolveResult", ctx, inheritedServicePbhResult)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetInheritedServicesPbhResolveResult indicates an expected call of SetInheritedServicesPbhResolveResult.
func (mr *MockStoreMockRecorder) SetInheritedServicesPbhResolveResult(ctx, inheritedServicePbhResult any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInheritedServicesPbhResolveResult", reflect.TypeOf((*MockStore)(nil).SetInheritedServicesPbhResolveResult), ctx, inheritedServicePbhResult)
}

// SetSpan mocks base method.
func (m *MockStore) SetSpan(ctx context.Context, span timespan.Span) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSpan", ctx, span)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetSpan indicates an expected call of SetSpan.
func (mr *MockStoreMockRecorder) SetSpan(ctx, span any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSpan", reflect.TypeOf((*MockStore)(nil).SetSpan), ctx, span)
}

// MockEntityTypeResolver is a mock of EntityTypeResolver interface.
type MockEntityTypeResolver struct {
	ctrl     *gomock.Controller
	recorder *MockEntityTypeResolverMockRecorder
	isgomock struct{}
}

// MockEntityTypeResolverMockRecorder is the mock recorder for MockEntityTypeResolver.
type MockEntityTypeResolverMockRecorder struct {
	mock *MockEntityTypeResolver
}

// NewMockEntityTypeResolver creates a new mock instance.
func NewMockEntityTypeResolver(ctrl *gomock.Controller) *MockEntityTypeResolver {
	mock := &MockEntityTypeResolver{ctrl: ctrl}
	mock.recorder = &MockEntityTypeResolverMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockEntityTypeResolver) EXPECT() *MockEntityTypeResolverMockRecorder {
	return m.recorder
}

// GetPbehaviors mocks base method.
func (m *MockEntityTypeResolver) GetPbehaviors(ctx context.Context, pbhIDs []string, t time.Time) (map[string]pbehavior.ResolveResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPbehaviors", ctx, pbhIDs, t)
	ret0, _ := ret[0].(map[string]pbehavior.ResolveResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPbehaviors indicates an expected call of GetPbehaviors.
func (mr *MockEntityTypeResolverMockRecorder) GetPbehaviors(ctx, pbhIDs, t any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPbehaviors", reflect.TypeOf((*MockEntityTypeResolver)(nil).GetPbehaviors), ctx, pbhIDs, t)
}

// Resolve mocks base method.
func (m *MockEntityTypeResolver) Resolve(ctx context.Context, entity types.Entity, t time.Time) (pbehavior.ResolveResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resolve", ctx, entity, t)
	ret0, _ := ret[0].(pbehavior.ResolveResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Resolve indicates an expected call of Resolve.
func (mr *MockEntityTypeResolverMockRecorder) Resolve(ctx, entity, t any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockEntityTypeResolver)(nil).Resolve), ctx, entity, t)
}

// MockComputedEntityTypeResolver is a mock of ComputedEntityTypeResolver interface.
type MockComputedEntityTypeResolver struct {
	ctrl     *gomock.Controller
	recorder *MockComputedEntityTypeResolverMockRecorder
	isgomock struct{}
}

// MockComputedEntityTypeResolverMockRecorder is the mock recorder for MockComputedEntityTypeResolver.
type MockComputedEntityTypeResolverMockRecorder struct {
	mock *MockComputedEntityTypeResolver
}

// NewMockComputedEntityTypeResolver creates a new mock instance.
func NewMockComputedEntityTypeResolver(ctrl *gomock.Controller) *MockComputedEntityTypeResolver {
	mock := &MockComputedEntityTypeResolver{ctrl: ctrl}
	mock.recorder = &MockComputedEntityTypeResolverMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockComputedEntityTypeResolver) EXPECT() *MockComputedEntityTypeResolverMockRecorder {
	return m.recorder
}

// GetComputedEntityIDs mocks base method.
func (m *MockComputedEntityTypeResolver) GetComputedEntityIDs() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputedEntityIDs")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetComputedEntityIDs indicates an expected call of GetComputedEntityIDs.
func (mr *MockComputedEntityTypeResolverMockRecorder) GetComputedEntityIDs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputedEntityIDs", reflect.TypeOf((*MockComputedEntityTypeResolver)(nil).GetComputedEntityIDs))
}

// GetComputedServicesWithInheritedPbhIDs mocks base method.
func (m *MockComputedEntityTypeResolver) GetComputedServicesWithInheritedPbhIDs() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComputedServicesWithInheritedPbhIDs")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetComputedServicesWithInheritedPbhIDs indicates an expected call of GetComputedServicesWithInheritedPbhIDs.
func (mr *MockComputedEntityTypeResolverMockRecorder) GetComputedServicesWithInheritedPbhIDs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComputedServicesWithInheritedPbhIDs", reflect.TypeOf((*MockComputedEntityTypeResolver)(nil).GetComputedServicesWithInheritedPbhIDs))
}

// GetPbehaviorsCount mocks base method.
func (m *MockComputedEntityTypeResolver) GetPbehaviorsCount(ctx context.Context, t time.Time) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPbehaviorsCount", ctx, t)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPbehaviorsCount indicates an expected call of GetPbehaviorsCount.
func (mr *MockComputedEntityTypeResolverMockRecorder) GetPbehaviorsCount(ctx, t any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPbehaviorsCount", reflect.TypeOf((*MockComputedEntityTypeResolver)(nil).GetPbehaviorsCount), ctx, t)
}

// Resolve mocks base method.
func (m *MockComputedEntityTypeResolver) Resolve(ctx context.Context, entity types.Entity, t time.Time) (pbehavior.ResolveResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resolve", ctx, entity, t)
	ret0, _ := ret[0].(pbehavior.ResolveResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Resolve indicates an expected call of Resolve.
func (mr *MockComputedEntityTypeResolverMockRecorder) Resolve(ctx, entity, t any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockComputedEntityTypeResolver)(nil).Resolve), ctx, entity, t)
}

// MockTypeComputer is a mock of TypeComputer interface.
type MockTypeComputer struct {
	ctrl     *gomock.Controller
	recorder *MockTypeComputerMockRecorder
	isgomock struct{}
}

// MockTypeComputerMockRecorder is the mock recorder for MockTypeComputer.
type MockTypeComputerMockRecorder struct {
	mock *MockTypeComputer
}

// NewMockTypeComputer creates a new mock instance.
func NewMockTypeComputer(ctrl *gomock.Controller) *MockTypeComputer {
	mock := &MockTypeComputer{ctrl: ctrl}
	mock.recorder = &MockTypeComputerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTypeComputer) EXPECT() *MockTypeComputerMockRecorder {
	return m.recorder
}

// Compute mocks base method.
func (m *MockTypeComputer) Compute(ctx context.Context, span timespan.Span, location *time.Location) (pbehavior.ComputeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Compute", ctx, span, location)
	ret0, _ := ret[0].(pbehavior.ComputeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Compute indicates an expected call of Compute.
func (mr *MockTypeComputerMockRecorder) Compute(ctx, span, location any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compute", reflect.TypeOf((*MockTypeComputer)(nil).Compute), ctx, span, location)
}

// ComputeByIds mocks base method.
func (m *MockTypeComputer) ComputeByIds(ctx context.Context, span timespan.Span, pbehaviorIds []string, location *time.Location) (pbehavior.ComputeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ComputeByIds", ctx, span, pbehaviorIds, location)
	ret0, _ := ret[0].(pbehavior.ComputeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ComputeByIds indicates an expected call of ComputeByIds.
func (mr *MockTypeComputerMockRecorder) ComputeByIds(ctx, span, pbehaviorIds, location any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ComputeByIds", reflect.TypeOf((*MockTypeComputer)(nil).ComputeByIds), ctx, span, pbehaviorIds, location)
}

// MockInheritedServicePbhResolver is a mock of InheritedServicePbhResolver interface.
type MockInheritedServicePbhResolver struct {
	ctrl     *gomock.Controller
	recorder *MockInheritedServicePbhResolverMockRecorder
	isgomock struct{}
}

// MockInheritedServicePbhResolverMockRecorder is the mock recorder for MockInheritedServicePbhResolver.
type MockInheritedServicePbhResolverMockRecorder struct {
	mock *MockInheritedServicePbhResolver
}

// NewMockInheritedServicePbhResolver creates a new mock instance.
func NewMockInheritedServicePbhResolver(ctrl *gomock.Controller) *MockInheritedServicePbhResolver {
	mock := &MockInheritedServicePbhResolver{ctrl: ctrl}
	mock.recorder = &MockInheritedServicePbhResolverMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInheritedServicePbhResolver) EXPECT() *MockInheritedServicePbhResolverMockRecorder {
	return m.recorder
}

// ComputeAndResolveInheritedServicePbh mocks base method.
func (m *MockInheritedServicePbhResolver) ComputeAndResolveInheritedServicePbh(ctx context.Context, resolver pbehavior.ComputedEntityTypeResolver) (pbehavior.InheritedServicesPbhResolveResult, pbehavior.ServiceEventsData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ComputeAndResolveInheritedServicePbh", ctx, resolver)
	ret0, _ := ret[0].(pbehavior.InheritedServicesPbhResolveResult)
	ret1, _ := ret[1].(pbehavior.ServiceEventsData)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ComputeAndResolveInheritedServicePbh indicates an expected call of ComputeAndResolveInheritedServicePbh.
func (mr *MockInheritedServicePbhResolverMockRecorder) ComputeAndResolveInheritedServicePbh(ctx, resolver any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ComputeAndResolveInheritedServicePbh", reflect.TypeOf((*MockInheritedServicePbhResolver)(nil).ComputeAndResolveInheritedServicePbh), ctx, resolver)
}

// GetResolvedInheritedServicePbh mocks base method.
func (m *MockInheritedServicePbhResolver) GetResolvedInheritedServicePbh(ctx context.Context) (pbehavior.InheritedServicesPbhResolveResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResolvedInheritedServicePbh", ctx)
	ret0, _ := ret[0].(pbehavior.InheritedServicesPbhResolveResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResolvedInheritedServicePbh indicates an expected call of GetResolvedInheritedServicePbh.
func (mr *MockInheritedServicePbhResolverMockRecorder) GetResolvedInheritedServicePbh(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolvedInheritedServicePbh", reflect.TypeOf((*MockInheritedServicePbhResolver)(nil).GetResolvedInheritedServicePbh), ctx)
}
