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

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

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

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

// MockTxContext is a mock of TxContext interface.
type MockTxContext struct {
	ctrl     *gomock.Controller
	recorder *MockTxContextMockRecorder
}

// MockTxContextMockRecorder is the mock recorder for MockTxContext.
type MockTxContextMockRecorder struct {
	mock *MockTxContext
}

// NewMockTxContext creates a new mock instance.
func NewMockTxContext(ctrl *gomock.Controller) *MockTxContext {
	mock := &MockTxContext{ctrl: ctrl}
	mock.recorder = &MockTxContextMockRecorder{mock}
	return mock
}

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

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

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

// Deadline mocks base method.
func (m *MockTxContext) Deadline() (time.Time, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Deadline")
	ret0, _ := ret[0].(time.Time)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// Done mocks base method.
func (m *MockTxContext) Done() <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Done")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

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

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

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

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

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

// Value mocks base method.
func (m *MockTxContext) Value(key any) any {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value", key)
	ret0, _ := ret[0].(any)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockTxContextMockRecorder) Value(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockTxContext)(nil).Value), key)
}

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

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

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

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

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

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

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

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

// Close mocks base method.
func (m *MockStore) 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 *MockStoreMockRecorder) Close(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStore)(nil).Close), ctx)
}

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

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

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

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

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

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

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

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

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

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

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

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

// GetEventStore mocks base method.
func (m *MockStore) 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 *MockStoreMockRecorder) GetEventStore() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventStore", reflect.TypeOf((*MockStore)(nil).GetEventStore))
}

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

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

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

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

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

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

// GetJobByIDOrName mocks base method.
func (m *MockStore) GetJobByIDOrName(ctx context.Context, idOrName, namespace string) (models.Job, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJobByIDOrName", ctx, idOrName, namespace)
	ret0, _ := ret[0].(models.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetJobByName mocks base method.
func (m *MockStore) GetJobByName(ctx context.Context, name, namespace string) (models.Job, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJobByName", ctx, name, namespace)
	ret0, _ := ret[0].(models.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetJobHistory mocks base method.
func (m *MockStore) GetJobHistory(ctx context.Context, jobID string, options JobHistoryQuery) (*JobHistoryQueryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJobHistory", ctx, jobID, options)
	ret0, _ := ret[0].(*JobHistoryQueryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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