// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/zgen/taskgen/runner_gen.go
//
// Generated by this command:
//
//	mockgen -source pkg/zgen/taskgen/runner_gen.go -destination pkg/zgen/taskgen/runner_gen_mock.go -package taskgen
//

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

import (
	context "context"
	reflect "reflect"

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

// MockTaskRunner is a mock of TaskRunner interface.
type MockTaskRunner struct {
	ctrl     *gomock.Controller
	recorder *MockTaskRunnerMockRecorder
	isgomock struct{}
}

// MockTaskRunnerMockRecorder is the mock recorder for MockTaskRunner.
type MockTaskRunnerMockRecorder struct {
	mock *MockTaskRunner
}

// NewMockTaskRunner creates a new mock instance.
func NewMockTaskRunner(ctrl *gomock.Controller) *MockTaskRunner {
	mock := &MockTaskRunner{ctrl: ctrl}
	mock.recorder = &MockTaskRunnerMockRecorder{mock}
	return mock
}

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

// RunDeleteOpaqueKey mocks base method.
func (m *MockTaskRunner) RunDeleteOpaqueKey(ctx context.Context, params *DeleteOpaqueKeyParameters, overrides ...taskcore.TaskOverride) (int32, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range overrides {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunDeleteOpaqueKey", varargs...)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunDeleteOpaqueKey indicates an expected call of RunDeleteOpaqueKey.
func (mr *MockTaskRunnerMockRecorder) RunDeleteOpaqueKey(ctx, params any, overrides ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, overrides...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunDeleteOpaqueKey", reflect.TypeOf((*MockTaskRunner)(nil).RunDeleteOpaqueKey), varargs...)
}

// RunDeleteOpaqueKeyWithTx mocks base method.
func (m *MockTaskRunner) RunDeleteOpaqueKeyWithTx(ctx context.Context, tx pgx.Tx, params *DeleteOpaqueKeyParameters, overrides ...taskcore.TaskOverride) (int32, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, tx, params}
	for _, a := range overrides {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunDeleteOpaqueKeyWithTx", varargs...)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunDeleteOpaqueKeyWithTx indicates an expected call of RunDeleteOpaqueKeyWithTx.
func (mr *MockTaskRunnerMockRecorder) RunDeleteOpaqueKeyWithTx(ctx, tx, params any, overrides ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, tx, params}, overrides...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunDeleteOpaqueKeyWithTx", reflect.TypeOf((*MockTaskRunner)(nil).RunDeleteOpaqueKeyWithTx), varargs...)
}

// MockExecutorInterface is a mock of ExecutorInterface interface.
type MockExecutorInterface struct {
	ctrl     *gomock.Controller
	recorder *MockExecutorInterfaceMockRecorder
	isgomock struct{}
}

// MockExecutorInterfaceMockRecorder is the mock recorder for MockExecutorInterface.
type MockExecutorInterfaceMockRecorder struct {
	mock *MockExecutorInterface
}

// NewMockExecutorInterface creates a new mock instance.
func NewMockExecutorInterface(ctrl *gomock.Controller) *MockExecutorInterface {
	mock := &MockExecutorInterface{ctrl: ctrl}
	mock.recorder = &MockExecutorInterfaceMockRecorder{mock}
	return mock
}

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

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

// ExecuteDeleteOpaqueKey indicates an expected call of ExecuteDeleteOpaqueKey.
func (mr *MockExecutorInterfaceMockRecorder) ExecuteDeleteOpaqueKey(ctx, tx, params any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteDeleteOpaqueKey", reflect.TypeOf((*MockExecutorInterface)(nil).ExecuteDeleteOpaqueKey), ctx, tx, params)
}

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

// OnDeleteOpaqueKeyFailed indicates an expected call of OnDeleteOpaqueKeyFailed.
func (mr *MockExecutorInterfaceMockRecorder) OnDeleteOpaqueKeyFailed(ctx, taskID, params, tx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnDeleteOpaqueKeyFailed", reflect.TypeOf((*MockExecutorInterface)(nil).OnDeleteOpaqueKeyFailed), ctx, taskID, params, tx)
}
