// Code generated by MockGen. DO NOT EDIT.
// Source: ./run.go
//
// Generated by this command:
//
//	mockgen -package entity -source ./run.go -destination ./run_mock.go
//

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

import (
	context "context"
	reflect "reflect"

	drivenadapters "github.com/kweaver-ai/kweaver-core/adp/dataflow/flow-automation/drivenadapters"
	dependency "github.com/kweaver-ai/kweaver-core/adp/dataflow/flow-automation/pkg/dependency"
	utils "github.com/kweaver-ai/kweaver-core/adp/dataflow/flow-automation/pkg/utils"
	gomock "go.uber.org/mock/gomock"
)

// MockExecuteContext is a mock of ExecuteContext interface.
type MockExecuteContext struct {
	ctrl     *gomock.Controller
	recorder *MockExecuteContextMockRecorder
	isgomock struct{}
}

// MockExecuteContextMockRecorder is the mock recorder for MockExecuteContext.
type MockExecuteContextMockRecorder struct {
	mock *MockExecuteContext
}

// NewMockExecuteContext creates a new mock instance.
func NewMockExecuteContext(ctrl *gomock.Controller) *MockExecuteContext {
	mock := &MockExecuteContext{ctrl: ctrl}
	mock.recorder = &MockExecuteContextMockRecorder{mock}
	return mock
}

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

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

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

// GetParam mocks base method.
func (m *MockExecuteContext) GetParam(paramName string) (any, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetParam", paramName)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetParam indicates an expected call of GetParam.
func (mr *MockExecuteContextMockRecorder) GetParam(paramName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParam", reflect.TypeOf((*MockExecuteContext)(nil).GetParam), paramName)
}

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

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

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

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

// GetVar mocks base method.
func (m *MockExecuteContext) GetVar(varName string) (any, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVar", varName)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetVar indicates an expected call of GetVar.
func (mr *MockExecuteContextMockRecorder) GetVar(varName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVar", reflect.TypeOf((*MockExecuteContext)(nil).GetVar), varName)
}

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

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

// IterateVars mocks base method.
func (m *MockExecuteContext) IterateVars(iterateFunc utils.KeyValueIterateFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IterateVars", iterateFunc)
}

// IterateVars indicates an expected call of IterateVars.
func (mr *MockExecuteContextMockRecorder) IterateVars(iterateFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateVars", reflect.TypeOf((*MockExecuteContext)(nil).IterateVars), iterateFunc)
}

// NewASDoc mocks base method.
func (m *MockExecuteContext) NewASDoc() drivenadapters.Efast {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewASDoc")
	ret0, _ := ret[0].(drivenadapters.Efast)
	return ret0
}

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

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

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

// NewRepo mocks base method.
func (m *MockExecuteContext) NewRepo() dependency.Repo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRepo")
	ret0, _ := ret[0].(dependency.Repo)
	return ret0
}

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

// SetContext mocks base method.
func (m *MockExecuteContext) SetContext(ctx context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetContext", ctx)
}

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

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

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

// Trace mocks base method.
func (m *MockExecuteContext) Trace(ctx context.Context, msg string, opt ...TraceOp) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, msg}
	for _, a := range opt {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Trace", varargs...)
}

// Trace indicates an expected call of Trace.
func (mr *MockExecuteContextMockRecorder) Trace(ctx, msg any, opt ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, msg}, opt...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trace", reflect.TypeOf((*MockExecuteContext)(nil).Trace), varargs...)
}

// Tracef mocks base method.
func (m *MockExecuteContext) Tracef(ctx context.Context, msg string, a ...any) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, msg}
	for _, a_2 := range a {
		varargs = append(varargs, a_2)
	}
	m.ctrl.Call(m, "Tracef", varargs...)
}

// Tracef indicates an expected call of Tracef.
func (mr *MockExecuteContextMockRecorder) Tracef(ctx, msg any, a ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, msg}, a...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tracef", reflect.TypeOf((*MockExecuteContext)(nil).Tracef), varargs...)
}

// WithValue mocks base method.
func (m *MockExecuteContext) WithValue(key, value any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "WithValue", key, value)
}

// WithValue indicates an expected call of WithValue.
func (mr *MockExecuteContextMockRecorder) WithValue(key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithValue", reflect.TypeOf((*MockExecuteContext)(nil).WithValue), key, value)
}

// MockShareDataOperator is a mock of ShareDataOperator interface.
type MockShareDataOperator struct {
	ctrl     *gomock.Controller
	recorder *MockShareDataOperatorMockRecorder
	isgomock struct{}
}

// MockShareDataOperatorMockRecorder is the mock recorder for MockShareDataOperator.
type MockShareDataOperatorMockRecorder struct {
	mock *MockShareDataOperator
}

// NewMockShareDataOperator creates a new mock instance.
func NewMockShareDataOperator(ctrl *gomock.Controller) *MockShareDataOperator {
	mock := &MockShareDataOperator{ctrl: ctrl}
	mock.recorder = &MockShareDataOperatorMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockShareDataOperator) Get(key string) (any, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// Set mocks base method.
func (m *MockShareDataOperator) Set(key string, val any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Set", key, val)
}

// Set indicates an expected call of Set.
func (mr *MockShareDataOperatorMockRecorder) Set(key, val any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockShareDataOperator)(nil).Set), key, val)
}
