/*
 * Copyright 2025 coze-dev Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Code generated by MockGen. DO NOT EDIT.
// Source: interface.go
//
// Generated by this command:
//
//	mockgen -destination ../../internal/mock/domain/workflow/interface.go --package mockWorkflow -source interface.go
//

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

import (
	context "context"
	reflect "reflect"

	model "github.com/cloudwego/eino/components/model"
	compose "github.com/cloudwego/eino/compose"
	schema "github.com/cloudwego/eino/schema"
	workflow "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
	workflow0 "github.com/coze-dev/coze-studio/backend/api/model/workflow"
	workflow1 "github.com/coze-dev/coze-studio/backend/domain/workflow"
	config "github.com/coze-dev/coze-studio/backend/domain/workflow/config"
	entity "github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
	vo "github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
	storage "github.com/coze-dev/coze-studio/backend/infra/contract/storage"
	gomock "go.uber.org/mock/gomock"
)

// MockService is a mock of Service interface.
type MockService struct {
	ctrl     *gomock.Controller
	recorder *MockServiceMockRecorder
	isgomock struct{}
}

// MockServiceMockRecorder is the mock recorder for MockService.
type MockServiceMockRecorder struct {
	mock *MockService
}

// NewMockService creates a new mock instance.
func NewMockService(ctrl *gomock.Controller) *MockService {
	mock := &MockService{ctrl: ctrl}
	mock.recorder = &MockServiceMockRecorder{mock}
	return mock
}

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

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

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

// AsyncExecuteNode mocks base method.
func (m *MockService) AsyncExecuteNode(ctx context.Context, nodeID string, arg2 workflow.ExecuteConfig, input map[string]any) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AsyncExecuteNode", ctx, nodeID, arg2, input)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AsyncExecuteNode indicates an expected call of AsyncExecuteNode.
func (mr *MockServiceMockRecorder) AsyncExecuteNode(ctx, nodeID, arg2, input any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncExecuteNode", reflect.TypeOf((*MockService)(nil).AsyncExecuteNode), ctx, nodeID, arg2, input)
}

// AsyncResume mocks base method.
func (m *MockService) AsyncResume(ctx context.Context, req *entity.ResumeRequest, arg2 workflow.ExecuteConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AsyncResume", ctx, req, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AsyncResume indicates an expected call of AsyncResume.
func (mr *MockServiceMockRecorder) AsyncResume(ctx, req, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncResume", reflect.TypeOf((*MockService)(nil).AsyncResume), ctx, req, arg2)
}

// BindConvRelatedInfo mocks base method.
func (m *MockService) BindConvRelatedInfo(ctx context.Context, convID int64, info entity.ConvRelatedInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BindConvRelatedInfo", ctx, convID, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// BindConvRelatedInfo indicates an expected call of BindConvRelatedInfo.
func (mr *MockServiceMockRecorder) BindConvRelatedInfo(ctx, convID, info any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindConvRelatedInfo", reflect.TypeOf((*MockService)(nil).BindConvRelatedInfo), ctx, convID, info)
}

// Cancel mocks base method.
func (m *MockService) Cancel(ctx context.Context, wfExeID, wfID, spaceID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Cancel", ctx, wfExeID, wfID, spaceID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Cancel indicates an expected call of Cancel.
func (mr *MockServiceMockRecorder) Cancel(ctx, wfExeID, wfID, spaceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockService)(nil).Cancel), ctx, wfExeID, wfID, spaceID)
}

// CheckWorkflowsToReplace mocks base method.
func (m *MockService) CheckWorkflowsToReplace(ctx context.Context, appID, templateID int64) ([]*entity.Workflow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckWorkflowsToReplace", ctx, appID, templateID)
	ret0, _ := ret[0].([]*entity.Workflow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckWorkflowsToReplace indicates an expected call of CheckWorkflowsToReplace.
func (mr *MockServiceMockRecorder) CheckWorkflowsToReplace(ctx, appID, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckWorkflowsToReplace", reflect.TypeOf((*MockService)(nil).CheckWorkflowsToReplace), ctx, appID, templateID)
}

// CopyWorkflow mocks base method.
func (m *MockService) CopyWorkflow(ctx context.Context, workflowID int64, policy vo.CopyWorkflowPolicy) (*entity.Workflow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyWorkflow", ctx, workflowID, policy)
	ret0, _ := ret[0].(*entity.Workflow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyWorkflow indicates an expected call of CopyWorkflow.
func (mr *MockServiceMockRecorder) CopyWorkflow(ctx, workflowID, policy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyWorkflow", reflect.TypeOf((*MockService)(nil).CopyWorkflow), ctx, workflowID, policy)
}

// CopyWorkflowFromAppToLibrary mocks base method.
func (m *MockService) CopyWorkflowFromAppToLibrary(ctx context.Context, workflowID, appID int64, related vo.ExternalResourceRelated) (*entity.CopyWorkflowFromAppToLibraryResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyWorkflowFromAppToLibrary", ctx, workflowID, appID, related)
	ret0, _ := ret[0].(*entity.CopyWorkflowFromAppToLibraryResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyWorkflowFromAppToLibrary indicates an expected call of CopyWorkflowFromAppToLibrary.
func (mr *MockServiceMockRecorder) CopyWorkflowFromAppToLibrary(ctx, workflowID, appID, related any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyWorkflowFromAppToLibrary", reflect.TypeOf((*MockService)(nil).CopyWorkflowFromAppToLibrary), ctx, workflowID, appID, related)
}

// Create mocks base method.
func (m *MockService) Create(ctx context.Context, meta *vo.MetaCreate) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, meta)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateChatFlowRole mocks base method.
func (m *MockService) CreateChatFlowRole(ctx context.Context, role *vo.ChatFlowRoleCreate) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChatFlowRole", ctx, role)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDraftConversationTemplate mocks base method.
func (m *MockService) CreateDraftConversationTemplate(ctx context.Context, template *vo.CreateConversationTemplateMeta) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDraftConversationTemplate", ctx, template)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Delete mocks base method.
func (m *MockService) Delete(ctx context.Context, policy *vo.DeletePolicy) ([]int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, policy)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

// DeleteDraftConversationTemplate indicates an expected call of DeleteDraftConversationTemplate.
func (mr *MockServiceMockRecorder) DeleteDraftConversationTemplate(ctx, templateID, wfID2ConversationName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDraftConversationTemplate", reflect.TypeOf((*MockService)(nil).DeleteDraftConversationTemplate), ctx, templateID, wfID2ConversationName)
}

// DeleteDynamicConversation mocks base method.
func (m *MockService) DeleteDynamicConversation(ctx context.Context, env vo.Env, templateID int64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDynamicConversation", ctx, env, templateID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDynamicConversation indicates an expected call of DeleteDynamicConversation.
func (mr *MockServiceMockRecorder) DeleteDynamicConversation(ctx, env, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDynamicConversation", reflect.TypeOf((*MockService)(nil).DeleteDynamicConversation), ctx, env, templateID)
}

// DuplicateWorkflowsByAppID mocks base method.
func (m *MockService) DuplicateWorkflowsByAppID(ctx context.Context, sourceAPPID, targetAppID int64, related vo.ExternalResourceRelated) ([]*entity.Workflow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DuplicateWorkflowsByAppID", ctx, sourceAPPID, targetAppID, related)
	ret0, _ := ret[0].([]*entity.Workflow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DuplicateWorkflowsByAppID indicates an expected call of DuplicateWorkflowsByAppID.
func (mr *MockServiceMockRecorder) DuplicateWorkflowsByAppID(ctx, sourceAPPID, targetAppID, related any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateWorkflowsByAppID", reflect.TypeOf((*MockService)(nil).DuplicateWorkflowsByAppID), ctx, sourceAPPID, targetAppID, related)
}

// Get mocks base method.
func (m *MockService) Get(ctx context.Context, policy *vo.GetPolicy) (*entity.Workflow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, policy)
	ret0, _ := ret[0].(*entity.Workflow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatFlowRole mocks base method.
func (m *MockService) GetChatFlowRole(ctx context.Context, workflowID int64, version string) (*entity.ChatFlowRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatFlowRole", ctx, workflowID, version)
	ret0, _ := ret[0].(*entity.ChatFlowRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatFlowRole indicates an expected call of GetChatFlowRole.
func (mr *MockServiceMockRecorder) GetChatFlowRole(ctx, workflowID, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatFlowRole", reflect.TypeOf((*MockService)(nil).GetChatFlowRole), ctx, workflowID, version)
}

// GetConvRelatedInfo mocks base method.
func (m *MockService) GetConvRelatedInfo(ctx context.Context, convID int64) (*entity.ConvRelatedInfo, bool, func() error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConvRelatedInfo", ctx, convID)
	ret0, _ := ret[0].(*entity.ConvRelatedInfo)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(func() error)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// GetConversationNameByID mocks base method.
func (m *MockService) GetConversationNameByID(ctx context.Context, env vo.Env, appID, connectorID, conversationID int64) (string, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConversationNameByID", ctx, env, appID, connectorID, conversationID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetConversationNameByID indicates an expected call of GetConversationNameByID.
func (mr *MockServiceMockRecorder) GetConversationNameByID(ctx, env, appID, connectorID, conversationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationNameByID", reflect.TypeOf((*MockService)(nil).GetConversationNameByID), ctx, env, appID, connectorID, conversationID)
}

// GetDynamicConversationByName mocks base method.
func (m *MockService) GetDynamicConversationByName(ctx context.Context, env vo.Env, appID, connectorID, userID int64, name string) (*entity.DynamicConversation, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDynamicConversationByName", ctx, env, appID, connectorID, userID, name)
	ret0, _ := ret[0].(*entity.DynamicConversation)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetDynamicConversationByName indicates an expected call of GetDynamicConversationByName.
func (mr *MockServiceMockRecorder) GetDynamicConversationByName(ctx, env, appID, connectorID, userID, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicConversationByName", reflect.TypeOf((*MockService)(nil).GetDynamicConversationByName), ctx, env, appID, connectorID, userID, name)
}

// GetExecution mocks base method.
func (m *MockService) GetExecution(ctx context.Context, wfExe *entity.WorkflowExecution, includeNodes bool) (*entity.WorkflowExecution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExecution", ctx, wfExe, includeNodes)
	ret0, _ := ret[0].(*entity.WorkflowExecution)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExecution indicates an expected call of GetExecution.
func (mr *MockServiceMockRecorder) GetExecution(ctx, wfExe, includeNodes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecution", reflect.TypeOf((*MockService)(nil).GetExecution), ctx, wfExe, includeNodes)
}

// GetLatestNodeDebugInput mocks base method.
func (m *MockService) GetLatestNodeDebugInput(ctx context.Context, wfID int64, nodeID string, userID int64) (*entity.NodeExecution, *entity.NodeExecution, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestNodeDebugInput", ctx, wfID, nodeID, userID)
	ret0, _ := ret[0].(*entity.NodeExecution)
	ret1, _ := ret[1].(*entity.NodeExecution)
	ret2, _ := ret[2].(bool)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// GetLatestNodeDebugInput indicates an expected call of GetLatestNodeDebugInput.
func (mr *MockServiceMockRecorder) GetLatestNodeDebugInput(ctx, wfID, nodeID, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestNodeDebugInput", reflect.TypeOf((*MockService)(nil).GetLatestNodeDebugInput), ctx, wfID, nodeID, userID)
}

// GetLatestTestRunInput mocks base method.
func (m *MockService) GetLatestTestRunInput(ctx context.Context, wfID, userID int64) (*entity.NodeExecution, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestTestRunInput", ctx, wfID, userID)
	ret0, _ := ret[0].(*entity.NodeExecution)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLatestTestRunInput indicates an expected call of GetLatestTestRunInput.
func (mr *MockServiceMockRecorder) GetLatestTestRunInput(ctx, wfID, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestTestRunInput", reflect.TypeOf((*MockService)(nil).GetLatestTestRunInput), ctx, wfID, userID)
}

// GetNodeExecution mocks base method.
func (m *MockService) GetNodeExecution(ctx context.Context, exeID int64, nodeID string) (*entity.NodeExecution, *entity.NodeExecution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeExecution", ctx, exeID, nodeID)
	ret0, _ := ret[0].(*entity.NodeExecution)
	ret1, _ := ret[1].(*entity.NodeExecution)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetNodeExecution indicates an expected call of GetNodeExecution.
func (mr *MockServiceMockRecorder) GetNodeExecution(ctx, exeID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeExecution", reflect.TypeOf((*MockService)(nil).GetNodeExecution), ctx, exeID, nodeID)
}

// GetOrCreateConversation mocks base method.
func (m *MockService) GetOrCreateConversation(ctx context.Context, env vo.Env, appID, connectorID, userID int64, conversationName string) (int64, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrCreateConversation", ctx, env, appID, connectorID, userID, conversationName)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetOrCreateConversation indicates an expected call of GetOrCreateConversation.
func (mr *MockServiceMockRecorder) GetOrCreateConversation(ctx, env, appID, connectorID, userID, conversationName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateConversation", reflect.TypeOf((*MockService)(nil).GetOrCreateConversation), ctx, env, appID, connectorID, userID, conversationName)
}

// GetTemplateByName mocks base method.
func (m *MockService) GetTemplateByName(ctx context.Context, env vo.Env, appID int64, templateName string) (*entity.ConversationTemplate, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateByName", ctx, env, appID, templateName)
	ret0, _ := ret[0].(*entity.ConversationTemplate)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetTemplateByName indicates an expected call of GetTemplateByName.
func (mr *MockServiceMockRecorder) GetTemplateByName(ctx, env, appID, templateName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateByName", reflect.TypeOf((*MockService)(nil).GetTemplateByName), ctx, env, appID, templateName)
}

// GetWorkflowDependenceResource mocks base method.
func (m *MockService) GetWorkflowDependenceResource(ctx context.Context, workflowID int64) (*vo.DependenceResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowDependenceResource", ctx, workflowID)
	ret0, _ := ret[0].(*vo.DependenceResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkflowReference mocks base method.
func (m *MockService) GetWorkflowReference(ctx context.Context, id int64) (map[int64]*vo.Meta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowReference", ctx, id)
	ret0, _ := ret[0].(map[int64]*vo.Meta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkflowVersionsByConnector mocks base method.
func (m *MockService) GetWorkflowVersionsByConnector(ctx context.Context, connectorID, workflowID int64, limit int) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowVersionsByConnector", ctx, connectorID, workflowID, limit)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkflowVersionsByConnector indicates an expected call of GetWorkflowVersionsByConnector.
func (mr *MockServiceMockRecorder) GetWorkflowVersionsByConnector(ctx, connectorID, workflowID, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowVersionsByConnector", reflect.TypeOf((*MockService)(nil).GetWorkflowVersionsByConnector), ctx, connectorID, workflowID, limit)
}

// InitApplicationDefaultConversationTemplate mocks base method.
func (m *MockService) InitApplicationDefaultConversationTemplate(ctx context.Context, spaceID, appID, userID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitApplicationDefaultConversationTemplate", ctx, spaceID, appID, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

// InitApplicationDefaultConversationTemplate indicates an expected call of InitApplicationDefaultConversationTemplate.
func (mr *MockServiceMockRecorder) InitApplicationDefaultConversationTemplate(ctx, spaceID, appID, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApplicationDefaultConversationTemplate", reflect.TypeOf((*MockService)(nil).InitApplicationDefaultConversationTemplate), ctx, spaceID, appID, userID)
}

// ListConversationTemplate mocks base method.
func (m *MockService) ListConversationTemplate(ctx context.Context, env vo.Env, policy *vo.ListConversationTemplatePolicy) ([]*entity.ConversationTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConversationTemplate", ctx, env, policy)
	ret0, _ := ret[0].([]*entity.ConversationTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConversationTemplate indicates an expected call of ListConversationTemplate.
func (mr *MockServiceMockRecorder) ListConversationTemplate(ctx, env, policy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConversationTemplate", reflect.TypeOf((*MockService)(nil).ListConversationTemplate), ctx, env, policy)
}

// ListDynamicConversation mocks base method.
func (m *MockService) ListDynamicConversation(ctx context.Context, env vo.Env, policy *vo.ListConversationPolicy) ([]*entity.DynamicConversation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDynamicConversation", ctx, env, policy)
	ret0, _ := ret[0].([]*entity.DynamicConversation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDynamicConversation indicates an expected call of ListDynamicConversation.
func (mr *MockServiceMockRecorder) ListDynamicConversation(ctx, env, policy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDynamicConversation", reflect.TypeOf((*MockService)(nil).ListDynamicConversation), ctx, env, policy)
}

// ListNodeMeta mocks base method.
func (m *MockService) ListNodeMeta(ctx context.Context, nodeTypes map[entity.NodeType]bool) (map[string][]*entity.NodeTypeMeta, []entity.Category, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodeMeta", ctx, nodeTypes)
	ret0, _ := ret[0].(map[string][]*entity.NodeTypeMeta)
	ret1, _ := ret[1].([]entity.Category)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MGet mocks base method.
func (m *MockService) MGet(ctx context.Context, policy *vo.MGetPolicy) ([]*entity.Workflow, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGet", ctx, policy)
	ret0, _ := ret[0].([]*entity.Workflow)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MGetStaticConversation mocks base method.
func (m *MockService) MGetStaticConversation(ctx context.Context, env vo.Env, userID, connectorID int64, templateIDs []int64) ([]*entity.StaticConversation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetStaticConversation", ctx, env, userID, connectorID, templateIDs)
	ret0, _ := ret[0].([]*entity.StaticConversation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MGetStaticConversation indicates an expected call of MGetStaticConversation.
func (mr *MockServiceMockRecorder) MGetStaticConversation(ctx, env, userID, connectorID, templateIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetStaticConversation", reflect.TypeOf((*MockService)(nil).MGetStaticConversation), ctx, env, userID, connectorID, templateIDs)
}

// Publish mocks base method.
func (m *MockService) Publish(ctx context.Context, policy *vo.PublishPolicy) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Publish", ctx, policy)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// PublishChatFlowRole mocks base method.
func (m *MockService) PublishChatFlowRole(ctx context.Context, policy *vo.PublishRolePolicy) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishChatFlowRole", ctx, policy)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// ReleaseApplicationWorkflows mocks base method.
func (m *MockService) ReleaseApplicationWorkflows(ctx context.Context, appID int64, arg2 *vo.ReleaseWorkflowConfig) ([]*vo.ValidateIssue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseApplicationWorkflows", ctx, appID, arg2)
	ret0, _ := ret[0].([]*vo.ValidateIssue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReleaseApplicationWorkflows indicates an expected call of ReleaseApplicationWorkflows.
func (mr *MockServiceMockRecorder) ReleaseApplicationWorkflows(ctx, appID, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseApplicationWorkflows", reflect.TypeOf((*MockService)(nil).ReleaseApplicationWorkflows), ctx, appID, arg2)
}

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

// ReleaseConversationTemplate indicates an expected call of ReleaseConversationTemplate.
func (mr *MockServiceMockRecorder) ReleaseConversationTemplate(ctx, appID, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseConversationTemplate", reflect.TypeOf((*MockService)(nil).ReleaseConversationTemplate), ctx, appID, version)
}

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

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

// StreamExecute mocks base method.
func (m *MockService) StreamExecute(ctx context.Context, arg1 workflow.ExecuteConfig, input map[string]any) (*schema.StreamReader[*entity.Message], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamExecute", ctx, arg1, input)
	ret0, _ := ret[0].(*schema.StreamReader[*entity.Message])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StreamResume mocks base method.
func (m *MockService) StreamResume(ctx context.Context, req *entity.ResumeRequest, arg2 workflow.ExecuteConfig) (*schema.StreamReader[*entity.Message], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamResume", ctx, req, arg2)
	ret0, _ := ret[0].(*schema.StreamReader[*entity.Message])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StreamResume indicates an expected call of StreamResume.
func (mr *MockServiceMockRecorder) StreamResume(ctx, req, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamResume", reflect.TypeOf((*MockService)(nil).StreamResume), ctx, req, arg2)
}

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

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

// SyncExecute mocks base method.
func (m *MockService) SyncExecute(ctx context.Context, arg1 workflow.ExecuteConfig, input map[string]any) (*entity.WorkflowExecution, vo.TerminatePlan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncExecute", ctx, arg1, input)
	ret0, _ := ret[0].(*entity.WorkflowExecution)
	ret1, _ := ret[1].(vo.TerminatePlan)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// SyncRelatedWorkflowResources mocks base method.
func (m *MockService) SyncRelatedWorkflowResources(ctx context.Context, appID int64, relatedWorkflows map[int64]entity.IDVersionPair, related vo.ExternalResourceRelated) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncRelatedWorkflowResources", ctx, appID, relatedWorkflows, related)
	ret0, _ := ret[0].(error)
	return ret0
}

// SyncRelatedWorkflowResources indicates an expected call of SyncRelatedWorkflowResources.
func (mr *MockServiceMockRecorder) SyncRelatedWorkflowResources(ctx, appID, relatedWorkflows, related any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncRelatedWorkflowResources", reflect.TypeOf((*MockService)(nil).SyncRelatedWorkflowResources), ctx, appID, relatedWorkflows, related)
}

// UpdateChatFlowRole mocks base method.
func (m *MockService) UpdateChatFlowRole(ctx context.Context, workflowID int64, role *vo.ChatFlowRoleUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatFlowRole", ctx, workflowID, role)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChatFlowRole indicates an expected call of UpdateChatFlowRole.
func (mr *MockServiceMockRecorder) UpdateChatFlowRole(ctx, workflowID, role any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatFlowRole", reflect.TypeOf((*MockService)(nil).UpdateChatFlowRole), ctx, workflowID, role)
}

// UpdateConversation mocks base method.
func (m *MockService) UpdateConversation(ctx context.Context, env vo.Env, appID, connectorID, userID int64, conversationName string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateConversation", ctx, env, appID, connectorID, userID, conversationName)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateConversation indicates an expected call of UpdateConversation.
func (mr *MockServiceMockRecorder) UpdateConversation(ctx, env, appID, connectorID, userID, conversationName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConversation", reflect.TypeOf((*MockService)(nil).UpdateConversation), ctx, env, appID, connectorID, userID, conversationName)
}

// UpdateDraftConversationTemplateName mocks base method.
func (m *MockService) UpdateDraftConversationTemplateName(ctx context.Context, appID, userID, templateID int64, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDraftConversationTemplateName", ctx, appID, userID, templateID, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDraftConversationTemplateName indicates an expected call of UpdateDraftConversationTemplateName.
func (mr *MockServiceMockRecorder) UpdateDraftConversationTemplateName(ctx, appID, userID, templateID, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftConversationTemplateName", reflect.TypeOf((*MockService)(nil).UpdateDraftConversationTemplateName), ctx, appID, userID, templateID, name)
}

// UpdateMeta mocks base method.
func (m *MockService) UpdateMeta(ctx context.Context, id int64, metaUpdate *vo.MetaUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMeta", ctx, id, metaUpdate)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ValidateTree mocks base method.
func (m *MockService) ValidateTree(ctx context.Context, id int64, validateConfig vo.ValidateTreeConfig) ([]*workflow0.ValidateTreeInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateTree", ctx, id, validateConfig)
	ret0, _ := ret[0].([]*workflow0.ValidateTreeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WithExecuteConfig mocks base method.
func (m *MockService) WithExecuteConfig(cfg workflow.ExecuteConfig) compose.Option {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithExecuteConfig", cfg)
	ret0, _ := ret[0].(compose.Option)
	return ret0
}

// WithExecuteConfig indicates an expected call of WithExecuteConfig.
func (mr *MockServiceMockRecorder) WithExecuteConfig(cfg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithExecuteConfig", reflect.TypeOf((*MockService)(nil).WithExecuteConfig), cfg)
}

// WithMessagePipe mocks base method.
func (m *MockService) WithMessagePipe() (compose.Option, *schema.StreamReader[*entity.Message], func()) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithMessagePipe")
	ret0, _ := ret[0].(compose.Option)
	ret1, _ := ret[1].(*schema.StreamReader[*entity.Message])
	ret2, _ := ret[2].(func())
	return ret0, ret1, ret2
}

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

// WithResumeToolWorkflow mocks base method.
func (m *MockService) WithResumeToolWorkflow(resumingEvent *entity.ToolInterruptEvent, resumeData string, allInterruptEvents map[string]*entity.ToolInterruptEvent) compose.Option {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithResumeToolWorkflow", resumingEvent, resumeData, allInterruptEvents)
	ret0, _ := ret[0].(compose.Option)
	return ret0
}

// WithResumeToolWorkflow indicates an expected call of WithResumeToolWorkflow.
func (mr *MockServiceMockRecorder) WithResumeToolWorkflow(resumingEvent, resumeData, allInterruptEvents any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithResumeToolWorkflow", reflect.TypeOf((*MockService)(nil).WithResumeToolWorkflow), resumingEvent, resumeData, allInterruptEvents)
}

// WorkflowAsModelTool mocks base method.
func (m *MockService) WorkflowAsModelTool(ctx context.Context, policies []*vo.GetPolicy) ([]workflow1.ToolFromWorkflow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WorkflowAsModelTool", ctx, policies)
	ret0, _ := ret[0].([]workflow1.ToolFromWorkflow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WorkflowSchemaCheck mocks base method.
func (m *MockService) WorkflowSchemaCheck(ctx context.Context, wf *entity.Workflow, checks []workflow0.CheckType) ([]*workflow0.CheckResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WorkflowSchemaCheck", ctx, wf, checks)
	ret0, _ := ret[0].([]*workflow0.CheckResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WorkflowSchemaCheck indicates an expected call of WorkflowSchemaCheck.
func (mr *MockServiceMockRecorder) WorkflowSchemaCheck(ctx, wf, checks any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkflowSchemaCheck", reflect.TypeOf((*MockService)(nil).WorkflowSchemaCheck), ctx, wf, checks)
}

// MockRepository is a mock of Repository interface.
type MockRepository struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryMockRecorder
	isgomock struct{}
}

// MockRepositoryMockRecorder is the mock recorder for MockRepository.
type MockRepositoryMockRecorder struct {
	mock *MockRepository
}

// NewMockRepository creates a new mock instance.
func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
	mock := &MockRepository{ctrl: ctrl}
	mock.recorder = &MockRepositoryMockRecorder{mock}
	return mock
}

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

// BatchCreateConnectorWorkflowVersion mocks base method.
func (m *MockRepository) BatchCreateConnectorWorkflowVersion(ctx context.Context, appID, connectorID int64, workflowIDs []int64, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCreateConnectorWorkflowVersion", ctx, appID, connectorID, workflowIDs, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchCreateConnectorWorkflowVersion indicates an expected call of BatchCreateConnectorWorkflowVersion.
func (mr *MockRepositoryMockRecorder) BatchCreateConnectorWorkflowVersion(ctx, appID, connectorID, workflowIDs, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateConnectorWorkflowVersion", reflect.TypeOf((*MockRepository)(nil).BatchCreateConnectorWorkflowVersion), ctx, appID, connectorID, workflowIDs, version)
}

// BatchCreateOnlineConversationTemplate mocks base method.
func (m *MockRepository) BatchCreateOnlineConversationTemplate(ctx context.Context, templates []*entity.ConversationTemplate, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCreateOnlineConversationTemplate", ctx, templates, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchCreateOnlineConversationTemplate indicates an expected call of BatchCreateOnlineConversationTemplate.
func (mr *MockRepositoryMockRecorder) BatchCreateOnlineConversationTemplate(ctx, templates, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateOnlineConversationTemplate", reflect.TypeOf((*MockRepository)(nil).BatchCreateOnlineConversationTemplate), ctx, templates, version)
}

// BindConvRelatedInfo mocks base method.
func (m *MockRepository) BindConvRelatedInfo(ctx context.Context, convID int64, info entity.ConvRelatedInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BindConvRelatedInfo", ctx, convID, info)
	ret0, _ := ret[0].(error)
	return ret0
}

// BindConvRelatedInfo indicates an expected call of BindConvRelatedInfo.
func (mr *MockRepositoryMockRecorder) BindConvRelatedInfo(ctx, convID, info any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindConvRelatedInfo", reflect.TypeOf((*MockRepository)(nil).BindConvRelatedInfo), ctx, convID, info)
}

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

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

// CopyTemplateConversationByAppID mocks base method.
func (m *MockRepository) CopyTemplateConversationByAppID(ctx context.Context, appID, toAppID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyTemplateConversationByAppID", ctx, appID, toAppID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CopyTemplateConversationByAppID indicates an expected call of CopyTemplateConversationByAppID.
func (mr *MockRepositoryMockRecorder) CopyTemplateConversationByAppID(ctx, appID, toAppID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyTemplateConversationByAppID", reflect.TypeOf((*MockRepository)(nil).CopyTemplateConversationByAppID), ctx, appID, toAppID)
}

// CopyWorkflow mocks base method.
func (m *MockRepository) CopyWorkflow(ctx context.Context, workflowID int64, policy vo.CopyWorkflowPolicy) (*entity.Workflow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyWorkflow", ctx, workflowID, policy)
	ret0, _ := ret[0].(*entity.Workflow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyWorkflow indicates an expected call of CopyWorkflow.
func (mr *MockRepositoryMockRecorder) CopyWorkflow(ctx, workflowID, policy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyWorkflow", reflect.TypeOf((*MockRepository)(nil).CopyWorkflow), ctx, workflowID, policy)
}

// CreateChatFlowRoleConfig mocks base method.
func (m *MockRepository) CreateChatFlowRoleConfig(ctx context.Context, chatFlowRole *entity.ChatFlowRole) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChatFlowRoleConfig", ctx, chatFlowRole)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDraftConversationTemplate mocks base method.
func (m *MockRepository) CreateDraftConversationTemplate(ctx context.Context, template *vo.CreateConversationTemplateMeta) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDraftConversationTemplate", ctx, template)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateMeta mocks base method.
func (m *MockRepository) CreateMeta(ctx context.Context, meta *vo.Meta) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMeta", ctx, meta)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CreateOrUpdateDraft mocks base method.
func (m *MockRepository) CreateOrUpdateDraft(ctx context.Context, id int64, draft *vo.DraftInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrUpdateDraft", ctx, id, draft)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// CreateVersion mocks base method.
func (m *MockRepository) CreateVersion(ctx context.Context, id int64, info *vo.VersionInfo, newRefs map[entity.WorkflowReferenceKey]struct{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVersion", ctx, id, info, newRefs)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateVersion indicates an expected call of CreateVersion.
func (mr *MockRepositoryMockRecorder) CreateVersion(ctx, id, info, newRefs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVersion", reflect.TypeOf((*MockRepository)(nil).CreateVersion), ctx, id, info, newRefs)
}

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

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

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

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

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

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

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

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

// DeleteDynamicConversation mocks base method.
func (m *MockRepository) DeleteDynamicConversation(ctx context.Context, env vo.Env, id int64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDynamicConversation", ctx, env, id)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DraftV2 mocks base method.
func (m *MockRepository) DraftV2(ctx context.Context, id int64, commitID string) (*vo.DraftInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DraftV2", ctx, id, commitID)
	ret0, _ := ret[0].(*vo.DraftInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// Get mocks base method.
func (m *MockRepository) Get(ctx context.Context, checkPointID string) ([]byte, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, checkPointID)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetChatFlowRoleConfig mocks base method.
func (m *MockRepository) GetChatFlowRoleConfig(ctx context.Context, workflowID int64, version string) (*entity.ChatFlowRole, error, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatFlowRoleConfig", ctx, workflowID, version)
	ret0, _ := ret[0].(*entity.ChatFlowRole)
	ret1, _ := ret[1].(error)
	ret2, _ := ret[2].(bool)
	return ret0, ret1, ret2
}

// GetChatFlowRoleConfig indicates an expected call of GetChatFlowRoleConfig.
func (mr *MockRepositoryMockRecorder) GetChatFlowRoleConfig(ctx, workflowID, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatFlowRoleConfig", reflect.TypeOf((*MockRepository)(nil).GetChatFlowRoleConfig), ctx, workflowID, version)
}

// GetConvRelatedInfo mocks base method.
func (m *MockRepository) GetConvRelatedInfo(ctx context.Context, convID int64) (*entity.ConvRelatedInfo, bool, func() error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConvRelatedInfo", ctx, convID)
	ret0, _ := ret[0].(*entity.ConvRelatedInfo)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(func() error)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// GetConversationTemplate mocks base method.
func (m *MockRepository) GetConversationTemplate(ctx context.Context, env vo.Env, policy vo.GetConversationTemplatePolicy) (*entity.ConversationTemplate, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConversationTemplate", ctx, env, policy)
	ret0, _ := ret[0].(*entity.ConversationTemplate)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetConversationTemplate indicates an expected call of GetConversationTemplate.
func (mr *MockRepositoryMockRecorder) GetConversationTemplate(ctx, env, policy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationTemplate", reflect.TypeOf((*MockRepository)(nil).GetConversationTemplate), ctx, env, policy)
}

// GetDraftWorkflowsByAppID mocks base method.
func (m *MockRepository) GetDraftWorkflowsByAppID(ctx context.Context, AppID int64) (map[int64]*vo.DraftInfo, map[int64]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDraftWorkflowsByAppID", ctx, AppID)
	ret0, _ := ret[0].(map[int64]*vo.DraftInfo)
	ret1, _ := ret[1].(map[int64]string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetDynamicConversationByID mocks base method.
func (m *MockRepository) GetDynamicConversationByID(ctx context.Context, env vo.Env, appID, connectorID, conversationID int64) (*entity.DynamicConversation, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDynamicConversationByID", ctx, env, appID, connectorID, conversationID)
	ret0, _ := ret[0].(*entity.DynamicConversation)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetDynamicConversationByID indicates an expected call of GetDynamicConversationByID.
func (mr *MockRepositoryMockRecorder) GetDynamicConversationByID(ctx, env, appID, connectorID, conversationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicConversationByID", reflect.TypeOf((*MockRepository)(nil).GetDynamicConversationByID), ctx, env, appID, connectorID, conversationID)
}

// GetDynamicConversationByName mocks base method.
func (m *MockRepository) GetDynamicConversationByName(ctx context.Context, env vo.Env, appID, connectorID, userID int64, name string) (*entity.DynamicConversation, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDynamicConversationByName", ctx, env, appID, connectorID, userID, name)
	ret0, _ := ret[0].(*entity.DynamicConversation)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetDynamicConversationByName indicates an expected call of GetDynamicConversationByName.
func (mr *MockRepositoryMockRecorder) GetDynamicConversationByName(ctx, env, appID, connectorID, userID, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicConversationByName", reflect.TypeOf((*MockRepository)(nil).GetDynamicConversationByName), ctx, env, appID, connectorID, userID, name)
}

// GetEntity mocks base method.
func (m *MockRepository) GetEntity(ctx context.Context, policy *vo.GetPolicy) (*entity.Workflow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEntity", ctx, policy)
	ret0, _ := ret[0].(*entity.Workflow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFirstInterruptEvent mocks base method.
func (m *MockRepository) GetFirstInterruptEvent(ctx context.Context, wfExeID int64) (*entity.InterruptEvent, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFirstInterruptEvent", ctx, wfExeID)
	ret0, _ := ret[0].(*entity.InterruptEvent)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetKnowledgeRecallChatModel mocks base method.
func (m *MockRepository) GetKnowledgeRecallChatModel() model.BaseChatModel {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKnowledgeRecallChatModel")
	ret0, _ := ret[0].(model.BaseChatModel)
	return ret0
}

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

// GetLatestVersion mocks base method.
func (m *MockRepository) GetLatestVersion(ctx context.Context, id int64) (*vo.VersionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestVersion", ctx, id)
	ret0, _ := ret[0].(*vo.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMeta mocks base method.
func (m *MockRepository) GetMeta(ctx context.Context, id int64) (*vo.Meta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMeta", ctx, id)
	ret0, _ := ret[0].(*vo.Meta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNodeDebugLatestExeID mocks base method.
func (m *MockRepository) GetNodeDebugLatestExeID(ctx context.Context, wfID int64, nodeID string, uID int64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeDebugLatestExeID", ctx, wfID, nodeID, uID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeDebugLatestExeID indicates an expected call of GetNodeDebugLatestExeID.
func (mr *MockRepositoryMockRecorder) GetNodeDebugLatestExeID(ctx, wfID, nodeID, uID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeDebugLatestExeID", reflect.TypeOf((*MockRepository)(nil).GetNodeDebugLatestExeID), ctx, wfID, nodeID, uID)
}

// GetNodeExecution mocks base method.
func (m *MockRepository) GetNodeExecution(ctx context.Context, wfExeID int64, nodeID string) (*entity.NodeExecution, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeExecution", ctx, wfExeID, nodeID)
	ret0, _ := ret[0].(*entity.NodeExecution)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetNodeExecution indicates an expected call of GetNodeExecution.
func (mr *MockRepositoryMockRecorder) GetNodeExecution(ctx, wfExeID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeExecution", reflect.TypeOf((*MockRepository)(nil).GetNodeExecution), ctx, wfExeID, nodeID)
}

// GetNodeExecutionByParent mocks base method.
func (m *MockRepository) GetNodeExecutionByParent(ctx context.Context, wfExeID int64, parentNodeID string) ([]*entity.NodeExecution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeExecutionByParent", ctx, wfExeID, parentNodeID)
	ret0, _ := ret[0].([]*entity.NodeExecution)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeExecutionByParent indicates an expected call of GetNodeExecutionByParent.
func (mr *MockRepositoryMockRecorder) GetNodeExecutionByParent(ctx, wfExeID, parentNodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeExecutionByParent", reflect.TypeOf((*MockRepository)(nil).GetNodeExecutionByParent), ctx, wfExeID, parentNodeID)
}

// GetNodeExecutionsByWfExeID mocks base method.
func (m *MockRepository) GetNodeExecutionsByWfExeID(ctx context.Context, wfExeID int64) ([]*entity.NodeExecution, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeExecutionsByWfExeID", ctx, wfExeID)
	ret0, _ := ret[0].([]*entity.NodeExecution)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNodeOfCodeConfig mocks base method.
func (m *MockRepository) GetNodeOfCodeConfig() *config.NodeOfCodeConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeOfCodeConfig")
	ret0, _ := ret[0].(*config.NodeOfCodeConfig)
	return ret0
}

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

// GetObjectUrl mocks base method.
func (m *MockRepository) GetObjectUrl(ctx context.Context, objectKey string, opts ...storage.GetOptFn) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectKey}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectUrl", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectUrl indicates an expected call of GetObjectUrl.
func (mr *MockRepositoryMockRecorder) GetObjectUrl(ctx, objectKey any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, objectKey}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectUrl", reflect.TypeOf((*MockRepository)(nil).GetObjectUrl), varargs...)
}

// GetOrCreateDynamicConversation mocks base method.
func (m *MockRepository) GetOrCreateDynamicConversation(ctx context.Context, env vo.Env, idGen workflow1.ConversationIDGenerator, meta *vo.CreateDynamicConversation) (int64, int64, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrCreateDynamicConversation", ctx, env, idGen, meta)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(bool)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// GetOrCreateDynamicConversation indicates an expected call of GetOrCreateDynamicConversation.
func (mr *MockRepositoryMockRecorder) GetOrCreateDynamicConversation(ctx, env, idGen, meta any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateDynamicConversation", reflect.TypeOf((*MockRepository)(nil).GetOrCreateDynamicConversation), ctx, env, idGen, meta)
}

// GetOrCreateStaticConversation mocks base method.
func (m *MockRepository) GetOrCreateStaticConversation(ctx context.Context, env vo.Env, idGen workflow1.ConversationIDGenerator, meta *vo.CreateStaticConversation) (int64, int64, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrCreateStaticConversation", ctx, env, idGen, meta)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(bool)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// GetOrCreateStaticConversation indicates an expected call of GetOrCreateStaticConversation.
func (mr *MockRepositoryMockRecorder) GetOrCreateStaticConversation(ctx, env, idGen, meta any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateStaticConversation", reflect.TypeOf((*MockRepository)(nil).GetOrCreateStaticConversation), ctx, env, idGen, meta)
}

// GetStaticConversationByID mocks base method.
func (m *MockRepository) GetStaticConversationByID(ctx context.Context, env vo.Env, appID, connectorID, conversationID int64) (string, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStaticConversationByID", ctx, env, appID, connectorID, conversationID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStaticConversationByID indicates an expected call of GetStaticConversationByID.
func (mr *MockRepositoryMockRecorder) GetStaticConversationByID(ctx, env, appID, connectorID, conversationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStaticConversationByID", reflect.TypeOf((*MockRepository)(nil).GetStaticConversationByID), ctx, env, appID, connectorID, conversationID)
}

// GetStaticConversationByTemplateID mocks base method.
func (m *MockRepository) GetStaticConversationByTemplateID(ctx context.Context, env vo.Env, userID, connectorID, templateID int64) (*entity.StaticConversation, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStaticConversationByTemplateID", ctx, env, userID, connectorID, templateID)
	ret0, _ := ret[0].(*entity.StaticConversation)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStaticConversationByTemplateID indicates an expected call of GetStaticConversationByTemplateID.
func (mr *MockRepositoryMockRecorder) GetStaticConversationByTemplateID(ctx, env, userID, connectorID, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStaticConversationByTemplateID", reflect.TypeOf((*MockRepository)(nil).GetStaticConversationByTemplateID), ctx, env, userID, connectorID, templateID)
}

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

// GetTestRunLatestExeID indicates an expected call of GetTestRunLatestExeID.
func (mr *MockRepositoryMockRecorder) GetTestRunLatestExeID(ctx, wfID, uID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRunLatestExeID", reflect.TypeOf((*MockRepository)(nil).GetTestRunLatestExeID), ctx, wfID, uID)
}

// GetVersion mocks base method.
func (m *MockRepository) GetVersion(ctx context.Context, id int64, version string) (*vo.VersionInfo, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVersion", ctx, id, version)
	ret0, _ := ret[0].(*vo.VersionInfo)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetVersionListByConnectorAndWorkflowID mocks base method.
func (m *MockRepository) GetVersionListByConnectorAndWorkflowID(ctx context.Context, connectorID, workflowID int64, limit int) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVersionListByConnectorAndWorkflowID", ctx, connectorID, workflowID, limit)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVersionListByConnectorAndWorkflowID indicates an expected call of GetVersionListByConnectorAndWorkflowID.
func (mr *MockRepositoryMockRecorder) GetVersionListByConnectorAndWorkflowID(ctx, connectorID, workflowID, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersionListByConnectorAndWorkflowID", reflect.TypeOf((*MockRepository)(nil).GetVersionListByConnectorAndWorkflowID), ctx, connectorID, workflowID, limit)
}

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

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

// GetWorkflowExecution mocks base method.
func (m *MockRepository) GetWorkflowExecution(ctx context.Context, id int64) (*entity.WorkflowExecution, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecution", ctx, id)
	ret0, _ := ret[0].(*entity.WorkflowExecution)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// IsApplicationConnectorWorkflowVersion mocks base method.
func (m *MockRepository) IsApplicationConnectorWorkflowVersion(ctx context.Context, connectorID, workflowID int64, version string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsApplicationConnectorWorkflowVersion", ctx, connectorID, workflowID, version)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsApplicationConnectorWorkflowVersion indicates an expected call of IsApplicationConnectorWorkflowVersion.
func (mr *MockRepositoryMockRecorder) IsApplicationConnectorWorkflowVersion(ctx, connectorID, workflowID, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApplicationConnectorWorkflowVersion", reflect.TypeOf((*MockRepository)(nil).IsApplicationConnectorWorkflowVersion), ctx, connectorID, workflowID, version)
}

// ListConversationTemplate mocks base method.
func (m *MockRepository) ListConversationTemplate(ctx context.Context, env vo.Env, policy *vo.ListConversationTemplatePolicy) ([]*entity.ConversationTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConversationTemplate", ctx, env, policy)
	ret0, _ := ret[0].([]*entity.ConversationTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConversationTemplate indicates an expected call of ListConversationTemplate.
func (mr *MockRepositoryMockRecorder) ListConversationTemplate(ctx, env, policy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConversationTemplate", reflect.TypeOf((*MockRepository)(nil).ListConversationTemplate), ctx, env, policy)
}

// ListDynamicConversation mocks base method.
func (m *MockRepository) ListDynamicConversation(ctx context.Context, env vo.Env, policy *vo.ListConversationPolicy) ([]*entity.DynamicConversation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDynamicConversation", ctx, env, policy)
	ret0, _ := ret[0].([]*entity.DynamicConversation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDynamicConversation indicates an expected call of ListDynamicConversation.
func (mr *MockRepositoryMockRecorder) ListDynamicConversation(ctx, env, policy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDynamicConversation", reflect.TypeOf((*MockRepository)(nil).ListDynamicConversation), ctx, env, policy)
}

// ListInterruptEvents mocks base method.
func (m *MockRepository) ListInterruptEvents(ctx context.Context, wfExeID int64) ([]*entity.InterruptEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInterruptEvents", ctx, wfExeID)
	ret0, _ := ret[0].([]*entity.InterruptEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MGetDrafts mocks base method.
func (m *MockRepository) MGetDrafts(ctx context.Context, policy *vo.MGetPolicy) ([]*entity.Workflow, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetDrafts", ctx, policy)
	ret0, _ := ret[0].([]*entity.Workflow)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MGetLatestVersion mocks base method.
func (m *MockRepository) MGetLatestVersion(ctx context.Context, policy *vo.MGetPolicy) ([]*entity.Workflow, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetLatestVersion", ctx, policy)
	ret0, _ := ret[0].([]*entity.Workflow)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MGetMetas mocks base method.
func (m *MockRepository) MGetMetas(ctx context.Context, query *vo.MetaQuery) (map[int64]*vo.Meta, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetMetas", ctx, query)
	ret0, _ := ret[0].(map[int64]*vo.Meta)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MGetReferences mocks base method.
func (m *MockRepository) MGetReferences(ctx context.Context, policy *vo.MGetReferencePolicy) ([]*entity.WorkflowReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetReferences", ctx, policy)
	ret0, _ := ret[0].([]*entity.WorkflowReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MGetStaticConversation mocks base method.
func (m *MockRepository) MGetStaticConversation(ctx context.Context, env vo.Env, userID, connectorID int64, templateIDs []int64) ([]*entity.StaticConversation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetStaticConversation", ctx, env, userID, connectorID, templateIDs)
	ret0, _ := ret[0].([]*entity.StaticConversation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MGetStaticConversation indicates an expected call of MGetStaticConversation.
func (mr *MockRepositoryMockRecorder) MGetStaticConversation(ctx, env, userID, connectorID, templateIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetStaticConversation", reflect.TypeOf((*MockRepository)(nil).MGetStaticConversation), ctx, env, userID, connectorID, templateIDs)
}

// PopFirstInterruptEvent mocks base method.
func (m *MockRepository) PopFirstInterruptEvent(ctx context.Context, wfExeID int64) (*entity.InterruptEvent, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PopFirstInterruptEvent", ctx, wfExeID)
	ret0, _ := ret[0].(*entity.InterruptEvent)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// SaveInterruptEvents mocks base method.
func (m *MockRepository) SaveInterruptEvents(ctx context.Context, wfExeID int64, events []*entity.InterruptEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveInterruptEvents", ctx, wfExeID, events)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveInterruptEvents indicates an expected call of SaveInterruptEvents.
func (mr *MockRepositoryMockRecorder) SaveInterruptEvents(ctx, wfExeID, events any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveInterruptEvents", reflect.TypeOf((*MockRepository)(nil).SaveInterruptEvents), ctx, wfExeID, events)
}

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

// Set indicates an expected call of Set.
func (mr *MockRepositoryMockRecorder) Set(ctx, checkPointID, checkPoint any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockRepository)(nil).Set), ctx, checkPointID, checkPoint)
}

// SetNodeDebugLatestExeID mocks base method.
func (m *MockRepository) SetNodeDebugLatestExeID(ctx context.Context, wfID int64, nodeID string, uID, exeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNodeDebugLatestExeID", ctx, wfID, nodeID, uID, exeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetNodeDebugLatestExeID indicates an expected call of SetNodeDebugLatestExeID.
func (mr *MockRepositoryMockRecorder) SetNodeDebugLatestExeID(ctx, wfID, nodeID, uID, exeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNodeDebugLatestExeID", reflect.TypeOf((*MockRepository)(nil).SetNodeDebugLatestExeID), ctx, wfID, nodeID, uID, exeID)
}

// SetTestRunLatestExeID mocks base method.
func (m *MockRepository) SetTestRunLatestExeID(ctx context.Context, wfID, uID, exeID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTestRunLatestExeID", ctx, wfID, uID, exeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetTestRunLatestExeID indicates an expected call of SetTestRunLatestExeID.
func (mr *MockRepositoryMockRecorder) SetTestRunLatestExeID(ctx, wfID, uID, exeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTestRunLatestExeID", reflect.TypeOf((*MockRepository)(nil).SetTestRunLatestExeID), ctx, wfID, uID, exeID)
}

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

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

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

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

// TryLockWorkflowExecution mocks base method.
func (m *MockRepository) TryLockWorkflowExecution(ctx context.Context, wfExeID, resumingEventID int64) (bool, entity.WorkflowExecuteStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TryLockWorkflowExecution", ctx, wfExeID, resumingEventID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(entity.WorkflowExecuteStatus)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// TryLockWorkflowExecution indicates an expected call of TryLockWorkflowExecution.
func (mr *MockRepositoryMockRecorder) TryLockWorkflowExecution(ctx, wfExeID, resumingEventID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLockWorkflowExecution", reflect.TypeOf((*MockRepository)(nil).TryLockWorkflowExecution), ctx, wfExeID, resumingEventID)
}

// UpdateChatFlowRoleConfig mocks base method.
func (m *MockRepository) UpdateChatFlowRoleConfig(ctx context.Context, workflowID int64, chatFlowRole *vo.ChatFlowRoleUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatFlowRoleConfig", ctx, workflowID, chatFlowRole)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChatFlowRoleConfig indicates an expected call of UpdateChatFlowRoleConfig.
func (mr *MockRepositoryMockRecorder) UpdateChatFlowRoleConfig(ctx, workflowID, chatFlowRole any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatFlowRoleConfig", reflect.TypeOf((*MockRepository)(nil).UpdateChatFlowRoleConfig), ctx, workflowID, chatFlowRole)
}

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

// UpdateDraftConversationTemplateName indicates an expected call of UpdateDraftConversationTemplateName.
func (mr *MockRepositoryMockRecorder) UpdateDraftConversationTemplateName(ctx, templateID, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftConversationTemplateName", reflect.TypeOf((*MockRepository)(nil).UpdateDraftConversationTemplateName), ctx, templateID, name)
}

// UpdateDynamicConversation mocks base method.
func (m *MockRepository) UpdateDynamicConversation(ctx context.Context, env vo.Env, conversationID, newConversationID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDynamicConversation", ctx, env, conversationID, newConversationID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDynamicConversation indicates an expected call of UpdateDynamicConversation.
func (mr *MockRepositoryMockRecorder) UpdateDynamicConversation(ctx, env, conversationID, newConversationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDynamicConversation", reflect.TypeOf((*MockRepository)(nil).UpdateDynamicConversation), ctx, env, conversationID, newConversationID)
}

// UpdateDynamicConversationNameByID mocks base method.
func (m *MockRepository) UpdateDynamicConversationNameByID(ctx context.Context, env vo.Env, templateID int64, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDynamicConversationNameByID", ctx, env, templateID, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDynamicConversationNameByID indicates an expected call of UpdateDynamicConversationNameByID.
func (mr *MockRepositoryMockRecorder) UpdateDynamicConversationNameByID(ctx, env, templateID, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDynamicConversationNameByID", reflect.TypeOf((*MockRepository)(nil).UpdateDynamicConversationNameByID), ctx, env, templateID, name)
}

// UpdateFirstInterruptEvent mocks base method.
func (m *MockRepository) UpdateFirstInterruptEvent(ctx context.Context, wfExeID int64, event *entity.InterruptEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFirstInterruptEvent", ctx, wfExeID, event)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateFirstInterruptEvent indicates an expected call of UpdateFirstInterruptEvent.
func (mr *MockRepositoryMockRecorder) UpdateFirstInterruptEvent(ctx, wfExeID, event any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirstInterruptEvent", reflect.TypeOf((*MockRepository)(nil).UpdateFirstInterruptEvent), ctx, wfExeID, event)
}

// UpdateMeta mocks base method.
func (m *MockRepository) UpdateMeta(ctx context.Context, id int64, metaUpdate *vo.MetaUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMeta", ctx, id, metaUpdate)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// UpdateStaticConversation mocks base method.
func (m *MockRepository) UpdateStaticConversation(ctx context.Context, env vo.Env, templateID, connectorID, userID, newConversationID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateStaticConversation", ctx, env, templateID, connectorID, userID, newConversationID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStaticConversation indicates an expected call of UpdateStaticConversation.
func (mr *MockRepositoryMockRecorder) UpdateStaticConversation(ctx, env, templateID, connectorID, userID, newConversationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStaticConversation", reflect.TypeOf((*MockRepository)(nil).UpdateStaticConversation), ctx, env, templateID, connectorID, userID, newConversationID)
}

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

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

// UpdateWorkflowExecution mocks base method.
func (m *MockRepository) UpdateWorkflowExecution(ctx context.Context, execution *entity.WorkflowExecution, allowedStatus []entity.WorkflowExecuteStatus) (int64, entity.WorkflowExecuteStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowExecution", ctx, execution, allowedStatus)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(entity.WorkflowExecuteStatus)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateWorkflowExecution indicates an expected call of UpdateWorkflowExecution.
func (mr *MockRepositoryMockRecorder) UpdateWorkflowExecution(ctx, execution, allowedStatus any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecution", reflect.TypeOf((*MockRepository)(nil).UpdateWorkflowExecution), ctx, execution, allowedStatus)
}

// WorkflowAsTool mocks base method.
func (m *MockRepository) WorkflowAsTool(ctx context.Context, policy vo.GetPolicy, wfToolConfig vo.WorkflowToolConfig) (workflow1.ToolFromWorkflow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WorkflowAsTool", ctx, policy, wfToolConfig)
	ret0, _ := ret[0].(workflow1.ToolFromWorkflow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WorkflowAsTool indicates an expected call of WorkflowAsTool.
func (mr *MockRepositoryMockRecorder) WorkflowAsTool(ctx, policy, wfToolConfig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkflowAsTool", reflect.TypeOf((*MockRepository)(nil).WorkflowAsTool), ctx, policy, wfToolConfig)
}