// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/taskcore/worker/interfaces.go
//
// Generated by this command:
//
//	mockgen -source pkg/taskcore/worker/interfaces.go -destination pkg/taskcore/worker/mock_gen.go -package worker
//

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

import (
	context "context"
	json "encoding/json"
	reflect "reflect"

	apigen "github.com/cloudcarver/anclax/pkg/zgen/apigen"
	pgx "github.com/jackc/pgx/v5"
	gomock "go.uber.org/mock/gomock"
)

// MockTaskSpec is a mock of TaskSpec interface.
type MockTaskSpec struct {
	ctrl     *gomock.Controller
	recorder *MockTaskSpecMockRecorder
	isgomock struct{}
}

// MockTaskSpecMockRecorder is the mock recorder for MockTaskSpec.
type MockTaskSpecMockRecorder struct {
	mock *MockTaskSpec
}

// NewMockTaskSpec creates a new mock instance.
func NewMockTaskSpec(ctrl *gomock.Controller) *MockTaskSpec {
	mock := &MockTaskSpec{ctrl: ctrl}
	mock.recorder = &MockTaskSpecMockRecorder{mock}
	return mock
}

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

// GetPayload mocks base method.
func (m *MockTaskSpec) GetPayload() json.RawMessage {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPayload")
	ret0, _ := ret[0].(json.RawMessage)
	return ret0
}

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

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

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

// MockTaskHandler is a mock of TaskHandler interface.
type MockTaskHandler struct {
	ctrl     *gomock.Controller
	recorder *MockTaskHandlerMockRecorder
	isgomock struct{}
}

// MockTaskHandlerMockRecorder is the mock recorder for MockTaskHandler.
type MockTaskHandlerMockRecorder struct {
	mock *MockTaskHandler
}

// NewMockTaskHandler creates a new mock instance.
func NewMockTaskHandler(ctrl *gomock.Controller) *MockTaskHandler {
	mock := &MockTaskHandler{ctrl: ctrl}
	mock.recorder = &MockTaskHandlerMockRecorder{mock}
	return mock
}

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

// HandleTask mocks base method.
func (m *MockTaskHandler) HandleTask(ctx context.Context, tx pgx.Tx, spec TaskSpec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleTask", ctx, tx, spec)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleTask indicates an expected call of HandleTask.
func (mr *MockTaskHandlerMockRecorder) HandleTask(ctx, tx, spec any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleTask", reflect.TypeOf((*MockTaskHandler)(nil).HandleTask), ctx, tx, spec)
}

// OnTaskFailed mocks base method.
func (m *MockTaskHandler) OnTaskFailed(ctx context.Context, tx pgx.Tx, failedTaskSpec TaskSpec, taskID int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnTaskFailed", ctx, tx, failedTaskSpec, taskID)
	ret0, _ := ret[0].(error)
	return ret0
}

// OnTaskFailed indicates an expected call of OnTaskFailed.
func (mr *MockTaskHandlerMockRecorder) OnTaskFailed(ctx, tx, failedTaskSpec, taskID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnTaskFailed", reflect.TypeOf((*MockTaskHandler)(nil).OnTaskFailed), ctx, tx, failedTaskSpec, taskID)
}

// RegisterTaskHandler mocks base method.
func (m *MockTaskHandler) RegisterTaskHandler(handler TaskHandler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterTaskHandler", handler)
}

// RegisterTaskHandler indicates an expected call of RegisterTaskHandler.
func (mr *MockTaskHandlerMockRecorder) RegisterTaskHandler(handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskHandler", reflect.TypeOf((*MockTaskHandler)(nil).RegisterTaskHandler), handler)
}

// MockTaskLifeCycleHandlerInterface is a mock of TaskLifeCycleHandlerInterface interface.
type MockTaskLifeCycleHandlerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockTaskLifeCycleHandlerInterfaceMockRecorder
	isgomock struct{}
}

// MockTaskLifeCycleHandlerInterfaceMockRecorder is the mock recorder for MockTaskLifeCycleHandlerInterface.
type MockTaskLifeCycleHandlerInterfaceMockRecorder struct {
	mock *MockTaskLifeCycleHandlerInterface
}

// NewMockTaskLifeCycleHandlerInterface creates a new mock instance.
func NewMockTaskLifeCycleHandlerInterface(ctrl *gomock.Controller) *MockTaskLifeCycleHandlerInterface {
	mock := &MockTaskLifeCycleHandlerInterface{ctrl: ctrl}
	mock.recorder = &MockTaskLifeCycleHandlerInterfaceMockRecorder{mock}
	return mock
}

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

// HandleAttributes mocks base method.
func (m *MockTaskLifeCycleHandlerInterface) HandleAttributes(ctx context.Context, tx pgx.Tx, task apigen.Task) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleAttributes", ctx, tx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleAttributes indicates an expected call of HandleAttributes.
func (mr *MockTaskLifeCycleHandlerInterfaceMockRecorder) HandleAttributes(ctx, tx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleAttributes", reflect.TypeOf((*MockTaskLifeCycleHandlerInterface)(nil).HandleAttributes), ctx, tx, task)
}

// HandleCompleted mocks base method.
func (m *MockTaskLifeCycleHandlerInterface) HandleCompleted(ctx context.Context, tx pgx.Tx, task apigen.Task) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleCompleted", ctx, tx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleCompleted indicates an expected call of HandleCompleted.
func (mr *MockTaskLifeCycleHandlerInterfaceMockRecorder) HandleCompleted(ctx, tx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCompleted", reflect.TypeOf((*MockTaskLifeCycleHandlerInterface)(nil).HandleCompleted), ctx, tx, task)
}

// HandleFailed mocks base method.
func (m *MockTaskLifeCycleHandlerInterface) HandleFailed(ctx context.Context, tx pgx.Tx, task apigen.Task, err error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleFailed", ctx, tx, task, err)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleFailed indicates an expected call of HandleFailed.
func (mr *MockTaskLifeCycleHandlerInterfaceMockRecorder) HandleFailed(ctx, tx, task, err any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleFailed", reflect.TypeOf((*MockTaskLifeCycleHandlerInterface)(nil).HandleFailed), ctx, tx, task, err)
}

// MockWorkerInterface is a mock of WorkerInterface interface.
type MockWorkerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockWorkerInterfaceMockRecorder
	isgomock struct{}
}

// MockWorkerInterfaceMockRecorder is the mock recorder for MockWorkerInterface.
type MockWorkerInterfaceMockRecorder struct {
	mock *MockWorkerInterface
}

// NewMockWorkerInterface creates a new mock instance.
func NewMockWorkerInterface(ctrl *gomock.Controller) *MockWorkerInterface {
	mock := &MockWorkerInterface{ctrl: ctrl}
	mock.recorder = &MockWorkerInterfaceMockRecorder{mock}
	return mock
}

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

// RegisterTaskHandler mocks base method.
func (m *MockWorkerInterface) RegisterTaskHandler(handler TaskHandler) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterTaskHandler", handler)
}

// RegisterTaskHandler indicates an expected call of RegisterTaskHandler.
func (mr *MockWorkerInterfaceMockRecorder) RegisterTaskHandler(handler any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTaskHandler", reflect.TypeOf((*MockWorkerInterface)(nil).RegisterTaskHandler), handler)
}

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

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

// Start mocks base method.
func (m *MockWorkerInterface) Start() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start")
}

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