// Code generated by MockGen. DO NOT EDIT.
// Source: types.go

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

import (
	context "context"
	reflect "reflect"

	boltdblib "github.com/bacalhau-project/bacalhau/pkg/lib/boltdblib"
	watcher "github.com/bacalhau-project/bacalhau/pkg/lib/watcher"
	models "github.com/bacalhau-project/bacalhau/pkg/models"
	gomock "go.uber.org/mock/gomock"
)

// MockExecutionStore is a mock of ExecutionStore interface.
type MockExecutionStore struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionStoreMockRecorder
}

// MockExecutionStoreMockRecorder is the mock recorder for MockExecutionStore.
type MockExecutionStoreMockRecorder struct {
	mock *MockExecutionStore
}

// NewMockExecutionStore creates a new mock instance.
func NewMockExecutionStore(ctrl *gomock.Controller) *MockExecutionStore {
	mock := &MockExecutionStore{ctrl: ctrl}
	mock.recorder = &MockExecutionStoreMockRecorder{mock}
	return mock
}

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

// AddExecutionEvent mocks base method.
func (m *MockExecutionStore) AddExecutionEvent(ctx context.Context, executionID string, events ...*models.Event) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, executionID}
	for _, a := range events {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddExecutionEvent", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddExecutionEvent indicates an expected call of AddExecutionEvent.
func (mr *MockExecutionStoreMockRecorder) AddExecutionEvent(ctx, executionID interface{}, events ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, executionID}, events...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddExecutionEvent", reflect.TypeOf((*MockExecutionStore)(nil).AddExecutionEvent), varargs...)
}

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

// BeginTx indicates an expected call of BeginTx.
func (mr *MockExecutionStoreMockRecorder) BeginTx(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginTx", reflect.TypeOf((*MockExecutionStore)(nil).BeginTx), ctx)
}

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

// Close indicates an expected call of Close.
func (mr *MockExecutionStoreMockRecorder) Close(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockExecutionStore)(nil).Close), ctx)
}

// CreateExecution mocks base method.
func (m *MockExecutionStore) CreateExecution(ctx context.Context, execution models.Execution, events ...*models.Event) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, execution}
	for _, a := range events {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateExecution", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateExecution indicates an expected call of CreateExecution.
func (mr *MockExecutionStoreMockRecorder) CreateExecution(ctx, execution interface{}, events ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, execution}, events...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExecution", reflect.TypeOf((*MockExecutionStore)(nil).CreateExecution), varargs...)
}

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

// DeleteExecution indicates an expected call of DeleteExecution.
func (mr *MockExecutionStoreMockRecorder) DeleteExecution(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExecution", reflect.TypeOf((*MockExecutionStore)(nil).DeleteExecution), ctx, id)
}

// GetEventStore mocks base method.
func (m *MockExecutionStore) GetEventStore() watcher.EventStore {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEventStore")
	ret0, _ := ret[0].(watcher.EventStore)
	return ret0
}

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

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

// GetExecution indicates an expected call of GetExecution.
func (mr *MockExecutionStoreMockRecorder) GetExecution(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecution", reflect.TypeOf((*MockExecutionStore)(nil).GetExecution), ctx, id)
}

// GetExecutionCount mocks base method.
func (m *MockExecutionStore) GetExecutionCount(ctx context.Context, state models.ExecutionStateType) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExecutionCount", ctx, state)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExecutionCount indicates an expected call of GetExecutionCount.
func (mr *MockExecutionStoreMockRecorder) GetExecutionCount(ctx, state interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionCount", reflect.TypeOf((*MockExecutionStore)(nil).GetExecutionCount), ctx, state)
}

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

// GetExecutionEvents indicates an expected call of GetExecutionEvents.
func (mr *MockExecutionStoreMockRecorder) GetExecutionEvents(ctx, executionID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutionEvents", reflect.TypeOf((*MockExecutionStore)(nil).GetExecutionEvents), ctx, executionID)
}

// GetExecutions mocks base method.
func (m *MockExecutionStore) GetExecutions(ctx context.Context, jobID string) ([]*models.Execution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExecutions", ctx, jobID)
	ret0, _ := ret[0].([]*models.Execution)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExecutions indicates an expected call of GetExecutions.
func (mr *MockExecutionStoreMockRecorder) GetExecutions(ctx, jobID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecutions", reflect.TypeOf((*MockExecutionStore)(nil).GetExecutions), ctx, jobID)
}

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

// GetLiveExecutions indicates an expected call of GetLiveExecutions.
func (mr *MockExecutionStoreMockRecorder) GetLiveExecutions(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLiveExecutions", reflect.TypeOf((*MockExecutionStore)(nil).GetLiveExecutions), ctx)
}

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

// UpdateExecutionState indicates an expected call of UpdateExecutionState.
func (mr *MockExecutionStoreMockRecorder) UpdateExecutionState(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExecutionState", reflect.TypeOf((*MockExecutionStore)(nil).UpdateExecutionState), ctx, request)
}
