// Code generated by MockGen. DO NOT EDIT.
// Source: git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/metrics (interfaces: Sender)
//
// Generated by this command:
//
//	mockgen -destination=../../../mocks/lib/metrics/sender.go git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/metrics Sender
//

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

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

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

// MockSender is a mock of Sender interface.
type MockSender struct {
	ctrl     *gomock.Controller
	recorder *MockSenderMockRecorder
	isgomock struct{}
}

// MockSenderMockRecorder is the mock recorder for MockSender.
type MockSenderMockRecorder struct {
	mock *MockSender
}

// NewMockSender creates a new mock instance.
func NewMockSender(ctrl *gomock.Controller) *MockSender {
	mock := &MockSender{ctrl: ctrl}
	mock.recorder = &MockSenderMockRecorder{mock}
	return mock
}

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

// Run mocks base method.
func (m *MockSender) Run(ctx context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Run", ctx)
}

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

// SendAck mocks base method.
func (m *MockSender) SendAck(alarm types.Alarm, userID string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendAck", alarm, userID, timestamp)
}

// SendAck indicates an expected call of SendAck.
func (mr *MockSenderMockRecorder) SendAck(alarm, userID, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAck", reflect.TypeOf((*MockSender)(nil).SendAck), alarm, userID, timestamp)
}

// SendAutoInstructionAssignForInstructions mocks base method.
func (m *MockSender) SendAutoInstructionAssignForInstructions(instructionIDs []string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendAutoInstructionAssignForInstructions", instructionIDs, timestamp)
}

// SendAutoInstructionAssignForInstructions indicates an expected call of SendAutoInstructionAssignForInstructions.
func (mr *MockSenderMockRecorder) SendAutoInstructionAssignForInstructions(instructionIDs, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAutoInstructionAssignForInstructions", reflect.TypeOf((*MockSender)(nil).SendAutoInstructionAssignForInstructions), instructionIDs, timestamp)
}

// SendAutoInstructionExecutionForInstruction mocks base method.
func (m *MockSender) SendAutoInstructionExecutionForInstruction(instructionID string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendAutoInstructionExecutionForInstruction", instructionID, timestamp)
}

// SendAutoInstructionExecutionForInstruction indicates an expected call of SendAutoInstructionExecutionForInstruction.
func (mr *MockSenderMockRecorder) SendAutoInstructionExecutionForInstruction(instructionID, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAutoInstructionExecutionForInstruction", reflect.TypeOf((*MockSender)(nil).SendAutoInstructionExecutionForInstruction), instructionID, timestamp)
}

// SendAutoInstructionExecutionStart mocks base method.
func (m *MockSender) SendAutoInstructionExecutionStart(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendAutoInstructionExecutionStart", alarm, timestamp)
}

// SendAutoInstructionExecutionStart indicates an expected call of SendAutoInstructionExecutionStart.
func (mr *MockSenderMockRecorder) SendAutoInstructionExecutionStart(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAutoInstructionExecutionStart", reflect.TypeOf((*MockSender)(nil).SendAutoInstructionExecutionStart), alarm, timestamp)
}

// SendCancelAck mocks base method.
func (m *MockSender) SendCancelAck(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendCancelAck", alarm, timestamp)
}

// SendCancelAck indicates an expected call of SendCancelAck.
func (mr *MockSenderMockRecorder) SendCancelAck(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCancelAck", reflect.TypeOf((*MockSender)(nil).SendCancelAck), alarm, timestamp)
}

// SendCorrelation mocks base method.
func (m *MockSender) SendCorrelation(timestamp time.Time, child types.Alarm) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendCorrelation", timestamp, child)
}

// SendCorrelation indicates an expected call of SendCorrelation.
func (mr *MockSenderMockRecorder) SendCorrelation(timestamp, child any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCorrelation", reflect.TypeOf((*MockSender)(nil).SendCorrelation), timestamp, child)
}

// SendCreate mocks base method.
func (m *MockSender) SendCreate(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendCreate", alarm, timestamp)
}

// SendCreate indicates an expected call of SendCreate.
func (mr *MockSenderMockRecorder) SendCreate(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCreate", reflect.TypeOf((*MockSender)(nil).SendCreate), alarm, timestamp)
}

// SendCreateAndPbhEnter mocks base method.
func (m *MockSender) SendCreateAndPbhEnter(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendCreateAndPbhEnter", alarm, timestamp)
}

// SendCreateAndPbhEnter indicates an expected call of SendCreateAndPbhEnter.
func (mr *MockSenderMockRecorder) SendCreateAndPbhEnter(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCreateAndPbhEnter", reflect.TypeOf((*MockSender)(nil).SendCreateAndPbhEnter), alarm, timestamp)
}

// SendEventMetrics mocks base method.
func (m *MockSender) SendEventMetrics(alarm types.Alarm, entity types.Entity, alarmChange types.AlarmChange, timestamp time.Time, initiator, userID, instructionID, notAckedMetricType string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendEventMetrics", alarm, entity, alarmChange, timestamp, initiator, userID, instructionID, notAckedMetricType)
}

// SendEventMetrics indicates an expected call of SendEventMetrics.
func (mr *MockSenderMockRecorder) SendEventMetrics(alarm, entity, alarmChange, timestamp, initiator, userID, instructionID, notAckedMetricType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendEventMetrics", reflect.TypeOf((*MockSender)(nil).SendEventMetrics), alarm, entity, alarmChange, timestamp, initiator, userID, instructionID, notAckedMetricType)
}

// SendInstructionAssignForAlarm mocks base method.
func (m *MockSender) SendInstructionAssignForAlarm(entityID string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendInstructionAssignForAlarm", entityID, timestamp)
}

// SendInstructionAssignForAlarm indicates an expected call of SendInstructionAssignForAlarm.
func (mr *MockSenderMockRecorder) SendInstructionAssignForAlarm(entityID, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendInstructionAssignForAlarm", reflect.TypeOf((*MockSender)(nil).SendInstructionAssignForAlarm), entityID, timestamp)
}

// SendInstructionAssignForAlarms mocks base method.
func (m *MockSender) SendInstructionAssignForAlarms(entityIDs []string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendInstructionAssignForAlarms", entityIDs, timestamp)
}

// SendInstructionAssignForAlarms indicates an expected call of SendInstructionAssignForAlarms.
func (mr *MockSenderMockRecorder) SendInstructionAssignForAlarms(entityIDs, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendInstructionAssignForAlarms", reflect.TypeOf((*MockSender)(nil).SendInstructionAssignForAlarms), entityIDs, timestamp)
}

// SendInstructionAssignForInstruction mocks base method.
func (m *MockSender) SendInstructionAssignForInstruction(instructionID string, timestamp time.Time, value int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendInstructionAssignForInstruction", instructionID, timestamp, value)
}

// SendInstructionAssignForInstruction indicates an expected call of SendInstructionAssignForInstruction.
func (mr *MockSenderMockRecorder) SendInstructionAssignForInstruction(instructionID, timestamp, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendInstructionAssignForInstruction", reflect.TypeOf((*MockSender)(nil).SendInstructionAssignForInstruction), instructionID, timestamp, value)
}

// SendInstructionAssignForInstructions mocks base method.
func (m *MockSender) SendInstructionAssignForInstructions(instructionIDs []string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendInstructionAssignForInstructions", instructionIDs, timestamp)
}

// SendInstructionAssignForInstructions indicates an expected call of SendInstructionAssignForInstructions.
func (mr *MockSenderMockRecorder) SendInstructionAssignForInstructions(instructionIDs, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendInstructionAssignForInstructions", reflect.TypeOf((*MockSender)(nil).SendInstructionAssignForInstructions), instructionIDs, timestamp)
}

// SendInstructionExecutionForAlarm mocks base method.
func (m *MockSender) SendInstructionExecutionForAlarm(entityID string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendInstructionExecutionForAlarm", entityID, timestamp)
}

// SendInstructionExecutionForAlarm indicates an expected call of SendInstructionExecutionForAlarm.
func (mr *MockSenderMockRecorder) SendInstructionExecutionForAlarm(entityID, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendInstructionExecutionForAlarm", reflect.TypeOf((*MockSender)(nil).SendInstructionExecutionForAlarm), entityID, timestamp)
}

// SendInstructionExecutionForInstruction mocks base method.
func (m *MockSender) SendInstructionExecutionForInstruction(instructionID string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendInstructionExecutionForInstruction", instructionID, timestamp)
}

// SendInstructionExecutionForInstruction indicates an expected call of SendInstructionExecutionForInstruction.
func (mr *MockSenderMockRecorder) SendInstructionExecutionForInstruction(instructionID, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendInstructionExecutionForInstruction", reflect.TypeOf((*MockSender)(nil).SendInstructionExecutionForInstruction), instructionID, timestamp)
}

// SendMessageRate mocks base method.
func (m *MockSender) SendMessageRate(timestamp time.Time, eventType, connectorName string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendMessageRate", timestamp, eventType, connectorName)
}

// SendMessageRate indicates an expected call of SendMessageRate.
func (mr *MockSenderMockRecorder) SendMessageRate(timestamp, eventType, connectorName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageRate", reflect.TypeOf((*MockSender)(nil).SendMessageRate), timestamp, eventType, connectorName)
}

// SendNotAckedInDayDec mocks base method.
func (m *MockSender) SendNotAckedInDayDec(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendNotAckedInDayDec", alarm, timestamp)
}

// SendNotAckedInDayDec indicates an expected call of SendNotAckedInDayDec.
func (mr *MockSenderMockRecorder) SendNotAckedInDayDec(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNotAckedInDayDec", reflect.TypeOf((*MockSender)(nil).SendNotAckedInDayDec), alarm, timestamp)
}

// SendNotAckedInDayInc mocks base method.
func (m *MockSender) SendNotAckedInDayInc(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendNotAckedInDayInc", alarm, timestamp)
}

// SendNotAckedInDayInc indicates an expected call of SendNotAckedInDayInc.
func (mr *MockSenderMockRecorder) SendNotAckedInDayInc(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNotAckedInDayInc", reflect.TypeOf((*MockSender)(nil).SendNotAckedInDayInc), alarm, timestamp)
}

// SendNotAckedInFourHoursDec mocks base method.
func (m *MockSender) SendNotAckedInFourHoursDec(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendNotAckedInFourHoursDec", alarm, timestamp)
}

// SendNotAckedInFourHoursDec indicates an expected call of SendNotAckedInFourHoursDec.
func (mr *MockSenderMockRecorder) SendNotAckedInFourHoursDec(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNotAckedInFourHoursDec", reflect.TypeOf((*MockSender)(nil).SendNotAckedInFourHoursDec), alarm, timestamp)
}

// SendNotAckedInFourHoursInc mocks base method.
func (m *MockSender) SendNotAckedInFourHoursInc(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendNotAckedInFourHoursInc", alarm, timestamp)
}

// SendNotAckedInFourHoursInc indicates an expected call of SendNotAckedInFourHoursInc.
func (mr *MockSenderMockRecorder) SendNotAckedInFourHoursInc(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNotAckedInFourHoursInc", reflect.TypeOf((*MockSender)(nil).SendNotAckedInFourHoursInc), alarm, timestamp)
}

// SendNotAckedInHourDec mocks base method.
func (m *MockSender) SendNotAckedInHourDec(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendNotAckedInHourDec", alarm, timestamp)
}

// SendNotAckedInHourDec indicates an expected call of SendNotAckedInHourDec.
func (mr *MockSenderMockRecorder) SendNotAckedInHourDec(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNotAckedInHourDec", reflect.TypeOf((*MockSender)(nil).SendNotAckedInHourDec), alarm, timestamp)
}

// SendNotAckedInHourInc mocks base method.
func (m *MockSender) SendNotAckedInHourInc(alarm types.Alarm, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendNotAckedInHourInc", alarm, timestamp)
}

// SendNotAckedInHourInc indicates an expected call of SendNotAckedInHourInc.
func (mr *MockSenderMockRecorder) SendNotAckedInHourInc(alarm, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNotAckedInHourInc", reflect.TypeOf((*MockSender)(nil).SendNotAckedInHourInc), alarm, timestamp)
}

// SendPbhEnter mocks base method.
func (m *MockSender) SendPbhEnter(alarm types.Alarm, entity types.Entity) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendPbhEnter", alarm, entity)
}

// SendPbhEnter indicates an expected call of SendPbhEnter.
func (mr *MockSenderMockRecorder) SendPbhEnter(alarm, entity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPbhEnter", reflect.TypeOf((*MockSender)(nil).SendPbhEnter), alarm, entity)
}

// SendPbhLeave mocks base method.
func (m *MockSender) SendPbhLeave(entity types.Entity, timestamp time.Time, prevCanonicalType string, prevTimestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendPbhLeave", entity, timestamp, prevCanonicalType, prevTimestamp)
}

// SendPbhLeave indicates an expected call of SendPbhLeave.
func (mr *MockSenderMockRecorder) SendPbhLeave(entity, timestamp, prevCanonicalType, prevTimestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPbhLeave", reflect.TypeOf((*MockSender)(nil).SendPbhLeave), entity, timestamp, prevCanonicalType, prevTimestamp)
}

// SendPbhLeaveAndEnter mocks base method.
func (m *MockSender) SendPbhLeaveAndEnter(alarm types.Alarm, entity types.Entity, prevCanonicalType string, prevTimestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendPbhLeaveAndEnter", alarm, entity, prevCanonicalType, prevTimestamp)
}

// SendPbhLeaveAndEnter indicates an expected call of SendPbhLeaveAndEnter.
func (mr *MockSenderMockRecorder) SendPbhLeaveAndEnter(alarm, entity, prevCanonicalType, prevTimestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPbhLeaveAndEnter", reflect.TypeOf((*MockSender)(nil).SendPbhLeaveAndEnter), alarm, entity, prevCanonicalType, prevTimestamp)
}

// SendPerfData mocks base method.
func (m *MockSender) SendPerfData(timestamp time.Time, entityID, name string, value float64, unit string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendPerfData", timestamp, entityID, name, value, unit)
}

// SendPerfData indicates an expected call of SendPerfData.
func (mr *MockSenderMockRecorder) SendPerfData(timestamp, entityID, name, value, unit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPerfData", reflect.TypeOf((*MockSender)(nil).SendPerfData), timestamp, entityID, name, value, unit)
}

// SendRemoveNotAckedMetric mocks base method.
func (m *MockSender) SendRemoveNotAckedMetric(alarm types.Alarm, timestamp time.Time, notAckedMetricType string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendRemoveNotAckedMetric", alarm, timestamp, notAckedMetricType)
}

// SendRemoveNotAckedMetric indicates an expected call of SendRemoveNotAckedMetric.
func (mr *MockSenderMockRecorder) SendRemoveNotAckedMetric(alarm, timestamp, notAckedMetricType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRemoveNotAckedMetric", reflect.TypeOf((*MockSender)(nil).SendRemoveNotAckedMetric), alarm, timestamp, notAckedMetricType)
}

// SendResolve mocks base method.
func (m *MockSender) SendResolve(alarm types.Alarm, entity types.Entity, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendResolve", alarm, entity, timestamp)
}

// SendResolve indicates an expected call of SendResolve.
func (mr *MockSenderMockRecorder) SendResolve(alarm, entity, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendResolve", reflect.TypeOf((*MockSender)(nil).SendResolve), alarm, entity, timestamp)
}

// SendSliMetric mocks base method.
func (m *MockSender) SendSliMetric(timestamp time.Time, alarm types.Alarm, entity types.Entity) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendSliMetric", timestamp, alarm, entity)
}

// SendSliMetric indicates an expected call of SendSliMetric.
func (mr *MockSenderMockRecorder) SendSliMetric(timestamp, alarm, entity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendSliMetric", reflect.TypeOf((*MockSender)(nil).SendSliMetric), timestamp, alarm, entity)
}

// SendTicket mocks base method.
func (m *MockSender) SendTicket(alarm types.Alarm, userID string, timestamp time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendTicket", alarm, userID, timestamp)
}

// SendTicket indicates an expected call of SendTicket.
func (mr *MockSenderMockRecorder) SendTicket(alarm, userID, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTicket", reflect.TypeOf((*MockSender)(nil).SendTicket), alarm, userID, timestamp)
}

// SendUpdateState mocks base method.
func (m *MockSender) SendUpdateState(alarm types.Alarm, entity types.Entity, previousState types.CpsNumber) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendUpdateState", alarm, entity, previousState)
}

// SendUpdateState indicates an expected call of SendUpdateState.
func (mr *MockSenderMockRecorder) SendUpdateState(alarm, entity, previousState any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendUpdateState", reflect.TypeOf((*MockSender)(nil).SendUpdateState), alarm, entity, previousState)
}

// SendUserActivity mocks base method.
func (m *MockSender) SendUserActivity(timestamp time.Time, username string, value int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SendUserActivity", timestamp, username, value)
}

// SendUserActivity indicates an expected call of SendUserActivity.
func (mr *MockSenderMockRecorder) SendUserActivity(timestamp, username, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendUserActivity", reflect.TypeOf((*MockSender)(nil).SendUserActivity), timestamp, username, value)
}
