// Code generated by MockGen. DO NOT EDIT.
// Source: plugin.go
//
// Generated by this command:
//
//	mockgen -destination pluginmock/plugin_mock.go --package pluginmock -source plugin.go
//

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

import (
	context "context"
	reflect "reflect"

	schema "github.com/cloudwego/eino/schema"
	plugin "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/plugin"
	workflow "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
	plugin0 "github.com/coze-dev/coze-studio/backend/crossdomain/contract/plugin"
	gomock "go.uber.org/mock/gomock"
)

// MockPluginService is a mock of PluginService interface.
type MockPluginService struct {
	ctrl     *gomock.Controller
	recorder *MockPluginServiceMockRecorder
	isgomock struct{}
}

// MockPluginServiceMockRecorder is the mock recorder for MockPluginService.
type MockPluginServiceMockRecorder struct {
	mock *MockPluginService
}

// NewMockPluginService creates a new mock instance.
func NewMockPluginService(ctrl *gomock.Controller) *MockPluginService {
	mock := &MockPluginService{ctrl: ctrl}
	mock.recorder = &MockPluginServiceMockRecorder{mock}
	return mock
}

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

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

// BindAgentTools indicates an expected call of BindAgentTools.
func (mr *MockPluginServiceMockRecorder) BindAgentTools(ctx, agentID, toolIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindAgentTools", reflect.TypeOf((*MockPluginService)(nil).BindAgentTools), ctx, agentID, toolIDs)
}

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

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

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

// DuplicateDraftAgentTools indicates an expected call of DuplicateDraftAgentTools.
func (mr *MockPluginServiceMockRecorder) DuplicateDraftAgentTools(ctx, fromAgentID, toAgentID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateDraftAgentTools", reflect.TypeOf((*MockPluginService)(nil).DuplicateDraftAgentTools), ctx, fromAgentID, toAgentID)
}

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

// ExecutePlugin indicates an expected call of ExecutePlugin.
func (mr *MockPluginServiceMockRecorder) ExecutePlugin(ctx, input, pe, toolID, cfg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutePlugin", reflect.TypeOf((*MockPluginService)(nil).ExecutePlugin), ctx, input, pe, toolID, cfg)
}

// ExecuteTool mocks base method.
func (m *MockPluginService) ExecuteTool(ctx context.Context, req *plugin.ExecuteToolRequest, opts ...plugin.ExecuteToolOpt) (*plugin.ExecuteToolResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, req}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecuteTool", varargs...)
	ret0, _ := ret[0].(*plugin.ExecuteToolResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetPluginInvokableTools mocks base method.
func (m *MockPluginService) GetPluginInvokableTools(ctx context.Context, req *plugin.ToolsInvokableRequest) (map[int64]plugin0.InvokableTool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPluginInvokableTools", ctx, req)
	ret0, _ := ret[0].(map[int64]plugin0.InvokableTool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPluginToolsInfo mocks base method.
func (m *MockPluginService) GetPluginToolsInfo(ctx context.Context, req *plugin.ToolsInfoRequest) (*plugin.ToolsInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPluginToolsInfo", ctx, req)
	ret0, _ := ret[0].(*plugin.ToolsInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MGetAgentTools mocks base method.
func (m *MockPluginService) MGetAgentTools(ctx context.Context, req *plugin.MGetAgentToolsRequest) ([]*plugin.ToolInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetAgentTools", ctx, req)
	ret0, _ := ret[0].([]*plugin.ToolInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MGetVersionPlugins mocks base method.
func (m *MockPluginService) MGetVersionPlugins(ctx context.Context, versionPlugins []plugin.VersionPlugin) ([]*plugin.PluginInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetVersionPlugins", ctx, versionPlugins)
	ret0, _ := ret[0].([]*plugin.PluginInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MGetVersionTools mocks base method.
func (m *MockPluginService) MGetVersionTools(ctx context.Context, versionTools []plugin.VersionTool) ([]*plugin.ToolInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MGetVersionTools", ctx, versionTools)
	ret0, _ := ret[0].([]*plugin.ToolInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PublishAPPPlugins mocks base method.
func (m *MockPluginService) PublishAPPPlugins(ctx context.Context, req *plugin.PublishAPPPluginsRequest) (*plugin.PublishAPPPluginsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishAPPPlugins", ctx, req)
	ret0, _ := ret[0].(*plugin.PublishAPPPluginsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// PublishAgentTools indicates an expected call of PublishAgentTools.
func (mr *MockPluginServiceMockRecorder) PublishAgentTools(ctx, agentID, agentVersion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishAgentTools", reflect.TypeOf((*MockPluginService)(nil).PublishAgentTools), ctx, agentID, agentVersion)
}

// PublishPlugin mocks base method.
func (m *MockPluginService) PublishPlugin(ctx context.Context, req *plugin.PublishPluginRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishPlugin", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockInvokableTool is a mock of InvokableTool interface.
type MockInvokableTool struct {
	ctrl     *gomock.Controller
	recorder *MockInvokableToolMockRecorder
	isgomock struct{}
}

// MockInvokableToolMockRecorder is the mock recorder for MockInvokableTool.
type MockInvokableToolMockRecorder struct {
	mock *MockInvokableTool
}

// NewMockInvokableTool creates a new mock instance.
func NewMockInvokableTool(ctrl *gomock.Controller) *MockInvokableTool {
	mock := &MockInvokableTool{ctrl: ctrl}
	mock.recorder = &MockInvokableToolMockRecorder{mock}
	return mock
}

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

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

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

// PluginInvoke mocks base method.
func (m *MockInvokableTool) PluginInvoke(ctx context.Context, argumentsInJSON string, cfg workflow.ExecuteConfig) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PluginInvoke", ctx, argumentsInJSON, cfg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginInvoke indicates an expected call of PluginInvoke.
func (mr *MockInvokableToolMockRecorder) PluginInvoke(ctx, argumentsInJSON, cfg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginInvoke", reflect.TypeOf((*MockInvokableTool)(nil).PluginInvoke), ctx, argumentsInJSON, cfg)
}