// Code generated by MockGen. DO NOT EDIT.
// Source: ./mod_define.go
//
// Generated by this command:
//
//	mockgen -package mod -source ./mod_define.go -destination ./mod_define_mock.go
//

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

import (
	context "context"
	reflect "reflect"

	entity "github.com/kweaver-ai/kweaver-core/adp/dataflow/flow-automation/pkg/entity"
	bson "go.mongodb.org/mongo-driver/bson"
	options "go.mongodb.org/mongo-driver/mongo/options"
	gomock "go.uber.org/mock/gomock"
)

// MockCommander is a mock of Commander interface.
type MockCommander struct {
	ctrl     *gomock.Controller
	recorder *MockCommanderMockRecorder
	isgomock struct{}
}

// MockCommanderMockRecorder is the mock recorder for MockCommander.
type MockCommanderMockRecorder struct {
	mock *MockCommander
}

// NewMockCommander creates a new mock instance.
func NewMockCommander(ctrl *gomock.Controller) *MockCommander {
	mock := &MockCommander{ctrl: ctrl}
	mock.recorder = &MockCommanderMockRecorder{mock}
	return mock
}

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

// CancelTask mocks base method.
func (m *MockCommander) CancelTask(ctx context.Context, taskInsIds []string, ops ...CommandOptSetter) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, taskInsIds}
	for _, a := range ops {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelTask", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelTask indicates an expected call of CancelTask.
func (mr *MockCommanderMockRecorder) CancelTask(ctx, taskInsIds any, ops ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, taskInsIds}, ops...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelTask", reflect.TypeOf((*MockCommander)(nil).CancelTask), varargs...)
}

// RetryDagIns mocks base method.
func (m *MockCommander) RetryDagIns(ctx context.Context, dagInsId string, ops ...CommandOptSetter) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, dagInsId}
	for _, a := range ops {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RetryDagIns", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RetryDagIns indicates an expected call of RetryDagIns.
func (mr *MockCommanderMockRecorder) RetryDagIns(ctx, dagInsId any, ops ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, dagInsId}, ops...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryDagIns", reflect.TypeOf((*MockCommander)(nil).RetryDagIns), varargs...)
}

// RetryTask mocks base method.
func (m *MockCommander) RetryTask(ctx context.Context, taskInsIds []string, ops ...CommandOptSetter) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, taskInsIds}
	for _, a := range ops {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RetryTask", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RetryTask indicates an expected call of RetryTask.
func (mr *MockCommanderMockRecorder) RetryTask(ctx, taskInsIds any, ops ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, taskInsIds}, ops...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryTask", reflect.TypeOf((*MockCommander)(nil).RetryTask), varargs...)
}

// RunDag mocks base method.
func (m *MockCommander) RunDag(ctx context.Context, dagId string, specVar map[string]string) (*entity.DagInstance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunDag", ctx, dagId, specVar)
	ret0, _ := ret[0].(*entity.DagInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunDag indicates an expected call of RunDag.
func (mr *MockCommanderMockRecorder) RunDag(ctx, dagId, specVar any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunDag", reflect.TypeOf((*MockCommander)(nil).RunDag), ctx, dagId, specVar)
}

// MockExecutor is a mock of Executor interface.
type MockExecutor struct {
	ctrl     *gomock.Controller
	recorder *MockExecutorMockRecorder
	isgomock struct{}
}

// MockExecutorMockRecorder is the mock recorder for MockExecutor.
type MockExecutorMockRecorder struct {
	mock *MockExecutor
}

// NewMockExecutor creates a new mock instance.
func NewMockExecutor(ctrl *gomock.Controller) *MockExecutor {
	mock := &MockExecutor{ctrl: ctrl}
	mock.recorder = &MockExecutorMockRecorder{mock}
	return mock
}

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

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

// CancelTaskIns indicates an expected call of CancelTaskIns.
func (mr *MockExecutorMockRecorder) CancelTaskIns(taskInsIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelTaskIns", reflect.TypeOf((*MockExecutor)(nil).CancelTaskIns), taskInsIds)
}

// Push mocks base method.
func (m *MockExecutor) Push(dagIns *entity.DagInstance, taskIns *entity.TaskInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Push", dagIns, taskIns)
}

// Push indicates an expected call of Push.
func (mr *MockExecutorMockRecorder) Push(dagIns, taskIns any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockExecutor)(nil).Push), dagIns, taskIns)
}

// MockCloser is a mock of Closer interface.
type MockCloser struct {
	ctrl     *gomock.Controller
	recorder *MockCloserMockRecorder
	isgomock struct{}
}

// MockCloserMockRecorder is the mock recorder for MockCloser.
type MockCloserMockRecorder struct {
	mock *MockCloser
}

// NewMockCloser creates a new mock instance.
func NewMockCloser(ctrl *gomock.Controller) *MockCloser {
	mock := &MockCloser{ctrl: ctrl}
	mock.recorder = &MockCloserMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// CreateClient mocks base method.
func (m *MockStore) CreateClient(clientName, clientID, clientSecret string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClient", clientName, clientID, clientSecret)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateClient indicates an expected call of CreateClient.
func (mr *MockStoreMockRecorder) CreateClient(clientName, clientID, clientSecret any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockStore)(nil).CreateClient), clientName, clientID, clientSecret)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DisdinctDagInstance mocks base method.
func (m *MockStore) DisdinctDagInstance(input *ListDagInstanceInput) ([]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisdinctDagInstance", input)
	ret0, _ := ret[0].([]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetClient mocks base method.
func (m *MockStore) GetClient(clientName string) (*entity.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClient", clientName)
	ret0, _ := ret[0].(*entity.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetDagByFields mocks base method.
func (m *MockStore) GetDagByFields(ctx context.Context, params map[string]any) (*entity.Dag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDagByFields", ctx, params)
	ret0, _ := ret[0].(*entity.Dag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// GetDagInstanceByFields mocks base method.
func (m *MockStore) GetDagInstanceByFields(ctx context.Context, params map[string]any) (*entity.DagInstance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDagInstanceByFields", ctx, params)
	ret0, _ := ret[0].(*entity.DagInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetTokenByUserID mocks base method.
func (m *MockStore) GetTokenByUserID(userID string) (*entity.Token, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTokenByUserID", userID)
	ret0, _ := ret[0].(*entity.Token)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// ListDagByFields mocks base method.
func (m *MockStore) ListDagByFields(ctx context.Context, filter bson.M, opt options.FindOptions) ([]*entity.Dag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDagByFields", ctx, filter, opt)
	ret0, _ := ret[0].([]*entity.Dag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// ListDagInstanceInRangeTime mocks base method.
func (m *MockStore) ListDagInstanceInRangeTime(ctx context.Context, status string, begin, end int64) ([]*entity.DagInstance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDagInstanceInRangeTime", ctx, status, begin, end)
	ret0, _ := ret[0].([]*entity.DagInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// ListHistoryDagIns mocks base method.
func (m *MockStore) ListHistoryDagIns(ctx context.Context, params map[string]any, dataChannel chan []bson.M) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHistoryDagIns", ctx, params, dataChannel)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListHistoryTaskIns mocks base method.
func (m *MockStore) ListHistoryTaskIns(ctx context.Context, params map[string]any, dataChannel chan []bson.M) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHistoryTaskIns", ctx, params, dataChannel)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

// Marshal mocks base method.
func (m *MockStore) Marshal(obj any) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Marshal", obj)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PatchDagIns mocks base method.
func (m *MockStore) PatchDagIns(ctx context.Context, dagIns *entity.DagInstance, mustsPatchFields ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, dagIns}
	for _, a := range mustsPatchFields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchDagIns", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

// Unmarshal mocks base method.
func (m *MockStore) Unmarshal(bytes []byte, ptr any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unmarshal", bytes, ptr)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockKeeper is a mock of Keeper interface.
type MockKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockKeeperMockRecorder
	isgomock struct{}
}

// MockKeeperMockRecorder is the mock recorder for MockKeeper.
type MockKeeperMockRecorder struct {
	mock *MockKeeper
}

// NewMockKeeper creates a new mock instance.
func NewMockKeeper(ctrl *gomock.Controller) *MockKeeper {
	mock := &MockKeeper{ctrl: ctrl}
	mock.recorder = &MockKeeperMockRecorder{mock}
	return mock
}

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

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

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

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

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

// IsAlive mocks base method.
func (m *MockKeeper) IsAlive(workerKey string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsAlive", workerKey)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsAlive indicates an expected call of IsAlive.
func (mr *MockKeeperMockRecorder) IsAlive(workerKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAlive", reflect.TypeOf((*MockKeeper)(nil).IsAlive), workerKey)
}

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

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

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

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

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

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

// MockParser is a mock of Parser interface.
type MockParser struct {
	ctrl     *gomock.Controller
	recorder *MockParserMockRecorder
	isgomock struct{}
}

// MockParserMockRecorder is the mock recorder for MockParser.
type MockParserMockRecorder struct {
	mock *MockParser
}

// NewMockParser creates a new mock instance.
func NewMockParser(ctrl *gomock.Controller) *MockParser {
	mock := &MockParser{ctrl: ctrl}
	mock.recorder = &MockParserMockRecorder{mock}
	return mock
}

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

// EntryTaskIns mocks base method.
func (m *MockParser) EntryTaskIns(taskIns *entity.TaskInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EntryTaskIns", taskIns)
}

// EntryTaskIns indicates an expected call of EntryTaskIns.
func (mr *MockParserMockRecorder) EntryTaskIns(taskIns any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EntryTaskIns", reflect.TypeOf((*MockParser)(nil).EntryTaskIns), taskIns)
}

// InitialDagIns mocks base method.
func (m *MockParser) InitialDagIns(ctx context.Context, dagIns *entity.DagInstance) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitialDagIns", ctx, dagIns)
}

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

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

// RunDagIns indicates an expected call of RunDagIns.
func (mr *MockParserMockRecorder) RunDagIns(dagIns any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunDagIns", reflect.TypeOf((*MockParser)(nil).RunDagIns), dagIns)
}
