// Code generated by MockGen. DO NOT EDIT.
// Source: git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/action (interfaces: Adapter,DelayedScenarioManager,DelayedScenarioStorage,ScenarioExecutionStorage,ScenarioStorage,WorkerPool)
//
// Generated by this command:
//
//	mockgen -destination=../../../mocks/lib/canopsis/action/action.go git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/action Adapter,DelayedScenarioManager,DelayedScenarioStorage,ScenarioExecutionStorage,ScenarioStorage,WorkerPool
//

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

import (
	context "context"
	reflect "reflect"

	action "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/action"
	types "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/types"
	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
}

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

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

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

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

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

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

// MockDelayedScenarioManager is a mock of DelayedScenarioManager interface.
type MockDelayedScenarioManager struct {
	ctrl     *gomock.Controller
	recorder *MockDelayedScenarioManagerMockRecorder
	isgomock struct{}
}

// MockDelayedScenarioManagerMockRecorder is the mock recorder for MockDelayedScenarioManager.
type MockDelayedScenarioManagerMockRecorder struct {
	mock *MockDelayedScenarioManager
}

// NewMockDelayedScenarioManager creates a new mock instance.
func NewMockDelayedScenarioManager(ctrl *gomock.Controller) *MockDelayedScenarioManager {
	mock := &MockDelayedScenarioManager{ctrl: ctrl}
	mock.recorder = &MockDelayedScenarioManagerMockRecorder{mock}
	return mock
}

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

// AddDelayedScenario mocks base method.
func (m *MockDelayedScenarioManager) AddDelayedScenario(arg0 context.Context, arg1 types.Alarm, arg2 action.Scenario, arg3 action.AdditionalData) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddDelayedScenario", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// Run mocks base method.
func (m *MockDelayedScenarioManager) Run(arg0 context.Context) (<-chan action.DelayedScenarioTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", arg0)
	ret0, _ := ret[0].(<-chan action.DelayedScenarioTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockDelayedScenarioStorage is a mock of DelayedScenarioStorage interface.
type MockDelayedScenarioStorage struct {
	ctrl     *gomock.Controller
	recorder *MockDelayedScenarioStorageMockRecorder
	isgomock struct{}
}

// MockDelayedScenarioStorageMockRecorder is the mock recorder for MockDelayedScenarioStorage.
type MockDelayedScenarioStorageMockRecorder struct {
	mock *MockDelayedScenarioStorage
}

// NewMockDelayedScenarioStorage creates a new mock instance.
func NewMockDelayedScenarioStorage(ctrl *gomock.Controller) *MockDelayedScenarioStorage {
	mock := &MockDelayedScenarioStorage{ctrl: ctrl}
	mock.recorder = &MockDelayedScenarioStorageMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockDelayedScenarioStorage) Add(ctx context.Context, scenario action.DelayedScenario) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Add", ctx, scenario)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// Update mocks base method.
func (m *MockDelayedScenarioStorage) Update(ctx context.Context, scenario action.DelayedScenario) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, scenario)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockScenarioExecutionStorage is a mock of ScenarioExecutionStorage interface.
type MockScenarioExecutionStorage struct {
	ctrl     *gomock.Controller
	recorder *MockScenarioExecutionStorageMockRecorder
	isgomock struct{}
}

// MockScenarioExecutionStorageMockRecorder is the mock recorder for MockScenarioExecutionStorage.
type MockScenarioExecutionStorageMockRecorder struct {
	mock *MockScenarioExecutionStorage
}

// NewMockScenarioExecutionStorage creates a new mock instance.
func NewMockScenarioExecutionStorage(ctrl *gomock.Controller) *MockScenarioExecutionStorage {
	mock := &MockScenarioExecutionStorage{ctrl: ctrl}
	mock.recorder = &MockScenarioExecutionStorageMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m *MockScenarioExecutionStorage) Create(ctx context.Context, execution action.ScenarioExecution) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, execution)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// Get mocks base method.
func (m *MockScenarioExecutionStorage) Get(ctx context.Context, key string) (*action.ScenarioExecution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, key)
	ret0, _ := ret[0].(*action.ScenarioExecution)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// IncExecutedCount mocks base method.
func (m *MockScenarioExecutionStorage) IncExecutedCount(ctx context.Context, key string, inc int64, drop bool) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncExecutedCount", ctx, key, inc, drop)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IncExecutedCount indicates an expected call of IncExecutedCount.
func (mr *MockScenarioExecutionStorageMockRecorder) IncExecutedCount(ctx, key, inc, drop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncExecutedCount", reflect.TypeOf((*MockScenarioExecutionStorage)(nil).IncExecutedCount), ctx, key, inc, drop)
}

// IncExecutedWebhookCount mocks base method.
func (m *MockScenarioExecutionStorage) IncExecutedWebhookCount(ctx context.Context, key string, inc int64, drop bool) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncExecutedWebhookCount", ctx, key, inc, drop)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IncExecutedWebhookCount indicates an expected call of IncExecutedWebhookCount.
func (mr *MockScenarioExecutionStorageMockRecorder) IncExecutedWebhookCount(ctx, key, inc, drop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncExecutedWebhookCount", reflect.TypeOf((*MockScenarioExecutionStorage)(nil).IncExecutedWebhookCount), ctx, key, inc, drop)
}

// IncExecutingCount mocks base method.
func (m *MockScenarioExecutionStorage) IncExecutingCount(ctx context.Context, key string, inc int64, drop bool) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncExecutingCount", ctx, key, inc, drop)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IncExecutingCount indicates an expected call of IncExecutingCount.
func (mr *MockScenarioExecutionStorageMockRecorder) IncExecutingCount(ctx, key, inc, drop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncExecutingCount", reflect.TypeOf((*MockScenarioExecutionStorage)(nil).IncExecutingCount), ctx, key, inc, drop)
}

// Update mocks base method.
func (m *MockScenarioExecutionStorage) Update(ctx context.Context, execution action.ScenarioExecution) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, execution)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockScenarioStorage is a mock of ScenarioStorage interface.
type MockScenarioStorage struct {
	ctrl     *gomock.Controller
	recorder *MockScenarioStorageMockRecorder
	isgomock struct{}
}

// MockScenarioStorageMockRecorder is the mock recorder for MockScenarioStorage.
type MockScenarioStorageMockRecorder struct {
	mock *MockScenarioStorage
}

// NewMockScenarioStorage creates a new mock instance.
func NewMockScenarioStorage(ctrl *gomock.Controller) *MockScenarioStorage {
	mock := &MockScenarioStorage{ctrl: ctrl}
	mock.recorder = &MockScenarioStorageMockRecorder{mock}
	return mock
}

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

// GetScenario mocks base method.
func (m *MockScenarioStorage) GetScenario(id string) *action.Scenario {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScenario", id)
	ret0, _ := ret[0].(*action.Scenario)
	return ret0
}

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

// GetTriggeredScenarios mocks base method.
func (m *MockScenarioStorage) GetTriggeredScenarios(triggers []string, alarm types.Alarm) (map[string][]action.Scenario, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTriggeredScenarios", triggers, alarm)
	ret0, _ := ret[0].(map[string][]action.Scenario)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTriggeredScenarios indicates an expected call of GetTriggeredScenarios.
func (mr *MockScenarioStorageMockRecorder) GetTriggeredScenarios(triggers, alarm any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTriggeredScenarios", reflect.TypeOf((*MockScenarioStorage)(nil).GetTriggeredScenarios), triggers, alarm)
}

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

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

// RunDelayedScenarios mocks base method.
func (m *MockScenarioStorage) RunDelayedScenarios(ctx context.Context, triggers []string, alarm types.Alarm, entity types.Entity, additionalData action.AdditionalData) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunDelayedScenarios", ctx, triggers, alarm, entity, additionalData)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunDelayedScenarios indicates an expected call of RunDelayedScenarios.
func (mr *MockScenarioStorageMockRecorder) RunDelayedScenarios(ctx, triggers, alarm, entity, additionalData any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunDelayedScenarios", reflect.TypeOf((*MockScenarioStorage)(nil).RunDelayedScenarios), ctx, triggers, alarm, entity, additionalData)
}

// MockWorkerPool is a mock of WorkerPool interface.
type MockWorkerPool struct {
	ctrl     *gomock.Controller
	recorder *MockWorkerPoolMockRecorder
	isgomock struct{}
}

// MockWorkerPoolMockRecorder is the mock recorder for MockWorkerPool.
type MockWorkerPoolMockRecorder struct {
	mock *MockWorkerPool
}

// NewMockWorkerPool creates a new mock instance.
func NewMockWorkerPool(ctrl *gomock.Controller) *MockWorkerPool {
	mock := &MockWorkerPool{ctrl: ctrl}
	mock.recorder = &MockWorkerPoolMockRecorder{mock}
	return mock
}

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

// RunWorkers mocks base method.
func (m *MockWorkerPool) RunWorkers(ctx context.Context, taskChannel <-chan action.Task) (<-chan action.TaskResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunWorkers", ctx, taskChannel)
	ret0, _ := ret[0].(<-chan action.TaskResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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