// Code generated by MockGen. DO NOT EDIT.
// Source: git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/alarm (interfaces: Adapter,Service,EventProcessor,ActivationService)
//
// Generated by this command:
//
//	mockgen -destination=../../../mocks/lib/canopsis/alarm/alarm.go git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/alarm Adapter,Service,EventProcessor,ActivationService
//

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

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

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

// MockAdapter is a mock of Adapter interface.
type MockAdapter struct {
	ctrl     *gomock.Controller
	recorder *MockAdapterMockRecorder
	isgomock struct{}
}

// MockAdapterMockRecorder is the mock recorder for MockAdapter.
type MockAdapterMockRecorder struct {
	mock *MockAdapter
}

// NewMockAdapter creates a new mock instance.
func NewMockAdapter(ctrl *gomock.Controller) *MockAdapter {
	mock := &MockAdapter{ctrl: ctrl}
	mock.recorder = &MockAdapterMockRecorder{mock}
	return mock
}

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

// CopyAlarmToResolvedCollection mocks base method.
func (m *MockAdapter) CopyAlarmToResolvedCollection(ctx context.Context, alarm types.Alarm) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyAlarmToResolvedCollection", ctx, alarm)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CountResolvedAlarm mocks base method.
func (m *MockAdapter) CountResolvedAlarm(ctx context.Context, alarmList []string) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountResolvedAlarm", ctx, alarmList)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteResolvedAlarms mocks base method.
func (m *MockAdapter) DeleteResolvedAlarms(ctx context.Context, duration time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteResolvedAlarms", ctx, duration)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// FindToCheckPbehaviorInfo mocks base method.
func (m *MockAdapter) FindToCheckPbehaviorInfo(ctx context.Context, createdBefore datetime.CpsTime, idsWithPbehaviors, serviceIDs []string) (mongo.Cursor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindToCheckPbehaviorInfo", ctx, createdBefore, idsWithPbehaviors, serviceIDs)
	ret0, _ := ret[0].(mongo.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindToCheckPbehaviorInfo indicates an expected call of FindToCheckPbehaviorInfo.
func (mr *MockAdapterMockRecorder) FindToCheckPbehaviorInfo(ctx, createdBefore, idsWithPbehaviors, serviceIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindToCheckPbehaviorInfo", reflect.TypeOf((*MockAdapter)(nil).FindToCheckPbehaviorInfo), ctx, createdBefore, idsWithPbehaviors, serviceIDs)
}

// GetAlarmByAlarmId mocks base method.
func (m *MockAdapter) GetAlarmByAlarmId(ctx context.Context, id string) (types.Alarm, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAlarmByAlarmId", ctx, id)
	ret0, _ := ret[0].(types.Alarm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// GetAlarmsWithoutTicketByComponent mocks base method.
func (m *MockAdapter) GetAlarmsWithoutTicketByComponent(ctx context.Context, component string) ([]types.AlarmWithEntity, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAlarmsWithoutTicketByComponent", ctx, component)
	ret0, _ := ret[0].([]types.AlarmWithEntity)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCountOpenedAlarmsByIDs mocks base method.
func (m *MockAdapter) GetCountOpenedAlarmsByIDs(ctx context.Context, ids []string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCountOpenedAlarmsByIDs", ctx, ids)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLastAlarmByEntityID mocks base method.
func (m *MockAdapter) GetLastAlarmByEntityID(ctx context.Context, entityID string) (*types.Alarm, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastAlarmByEntityID", ctx, entityID)
	ret0, _ := ret[0].(*types.Alarm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOpenedAlarmByAlarmId mocks base method.
func (m *MockAdapter) GetOpenedAlarmByAlarmId(ctx context.Context, id string) (types.Alarm, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenedAlarmByAlarmId", ctx, id)
	ret0, _ := ret[0].(types.Alarm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOpenedAlarmsByAlarmIDs mocks base method.
func (m *MockAdapter) GetOpenedAlarmsByAlarmIDs(ctx context.Context, ids []string, alarms *[]types.Alarm) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenedAlarmsByAlarmIDs", ctx, ids, alarms)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetOpenedAlarmsByAlarmIDs indicates an expected call of GetOpenedAlarmsByAlarmIDs.
func (mr *MockAdapterMockRecorder) GetOpenedAlarmsByAlarmIDs(ctx, ids, alarms any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenedAlarmsByAlarmIDs", reflect.TypeOf((*MockAdapter)(nil).GetOpenedAlarmsByAlarmIDs), ctx, ids, alarms)
}

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

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

// GetOpenedAlarmsByIDs mocks base method.
func (m *MockAdapter) GetOpenedAlarmsByIDs(ctx context.Context, ids []string, alarms *[]types.Alarm) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenedAlarmsByIDs", ctx, ids, alarms)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetOpenedAlarmsByIDs indicates an expected call of GetOpenedAlarmsByIDs.
func (mr *MockAdapterMockRecorder) GetOpenedAlarmsByIDs(ctx, ids, alarms any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenedAlarmsByIDs", reflect.TypeOf((*MockAdapter)(nil).GetOpenedAlarmsByIDs), ctx, ids, alarms)
}

// GetOpenedAlarmsWithEntityByAlarmIDs mocks base method.
func (m *MockAdapter) GetOpenedAlarmsWithEntityByAlarmIDs(ctx context.Context, ids []string, alarms *[]types.AlarmWithEntity) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenedAlarmsWithEntityByAlarmIDs", ctx, ids, alarms)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetOpenedAlarmsWithEntityByAlarmIDs indicates an expected call of GetOpenedAlarmsWithEntityByAlarmIDs.
func (mr *MockAdapterMockRecorder) GetOpenedAlarmsWithEntityByAlarmIDs(ctx, ids, alarms any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenedAlarmsWithEntityByAlarmIDs", reflect.TypeOf((*MockAdapter)(nil).GetOpenedAlarmsWithEntityByAlarmIDs), ctx, ids, alarms)
}

// GetOpenedAlarmsWithEntityByIDs mocks base method.
func (m *MockAdapter) GetOpenedAlarmsWithEntityByIDs(ctx context.Context, ids []string, alarms *[]types.AlarmWithEntity) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenedAlarmsWithEntityByIDs", ctx, ids, alarms)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetOpenedAlarmsWithEntityByIDs indicates an expected call of GetOpenedAlarmsWithEntityByIDs.
func (mr *MockAdapterMockRecorder) GetOpenedAlarmsWithEntityByIDs(ctx, ids, alarms any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenedAlarmsWithEntityByIDs", reflect.TypeOf((*MockAdapter)(nil).GetOpenedAlarmsWithEntityByIDs), ctx, ids, alarms)
}

// GetOpenedAlarmsWithLastDatesBefore mocks base method.
func (m *MockAdapter) GetOpenedAlarmsWithLastDatesBefore(ctx context.Context, arg1 datetime.CpsTime) (mongo.Cursor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenedAlarmsWithLastDatesBefore", ctx, arg1)
	ret0, _ := ret[0].(mongo.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetWorstAlarmStateAndMaxLastEventDate mocks base method.
func (m *MockAdapter) GetWorstAlarmStateAndMaxLastEventDate(ctx context.Context, entityIds []string) (int64, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorstAlarmStateAndMaxLastEventDate", ctx, entityIds)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// UpdateLastEventDate mocks base method.
func (m *MockAdapter) UpdateLastEventDate(ctx context.Context, entityIds []string, t datetime.CpsTime) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLastEventDate", ctx, entityIds, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// 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
}

// ResolveCancels mocks base method.
func (m *MockService) ResolveCancels(ctx context.Context, alarmConfig config.AlarmConfig) ([]types.Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveCancels", ctx, alarmConfig)
	ret0, _ := ret[0].([]types.Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ResolveSnoozes mocks base method.
func (m *MockService) ResolveSnoozes(ctx context.Context, alarmConfig config.AlarmConfig) ([]types.Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveSnoozes", ctx, alarmConfig)
	ret0, _ := ret[0].([]types.Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockEventProcessor is a mock of EventProcessor interface.
type MockEventProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockEventProcessorMockRecorder
	isgomock struct{}
}

// MockEventProcessorMockRecorder is the mock recorder for MockEventProcessor.
type MockEventProcessorMockRecorder struct {
	mock *MockEventProcessor
}

// NewMockEventProcessor creates a new mock instance.
func NewMockEventProcessor(ctrl *gomock.Controller) *MockEventProcessor {
	mock := &MockEventProcessor{ctrl: ctrl}
	mock.recorder = &MockEventProcessorMockRecorder{mock}
	return mock
}

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

// Process mocks base method.
func (m *MockEventProcessor) Process(ctx context.Context, event *types.Event) (types.AlarmChange, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Process", ctx, event)
	ret0, _ := ret[0].(types.AlarmChange)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockActivationService is a mock of ActivationService interface.
type MockActivationService struct {
	ctrl     *gomock.Controller
	recorder *MockActivationServiceMockRecorder
	isgomock struct{}
}

// MockActivationServiceMockRecorder is the mock recorder for MockActivationService.
type MockActivationServiceMockRecorder struct {
	mock *MockActivationService
}

// NewMockActivationService creates a new mock instance.
func NewMockActivationService(ctrl *gomock.Controller) *MockActivationService {
	mock := &MockActivationService{ctrl: ctrl}
	mock.recorder = &MockActivationServiceMockRecorder{mock}
	return mock
}

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

// Process mocks base method.
func (m *MockActivationService) Process(ctx context.Context, alarm types.Alarm, fifoAckEvent types.Event) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Process", ctx, alarm, fifoAckEvent)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Process indicates an expected call of Process.
func (mr *MockActivationServiceMockRecorder) Process(ctx, alarm, fifoAckEvent any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Process", reflect.TypeOf((*MockActivationService)(nil).Process), ctx, alarm, fifoAckEvent)
}
