// Code generated by MockGen. DO NOT EDIT.
// Source: logics_mcp.go
//
// Generated by this command:
//
//	mockgen -source=logics_mcp.go -destination=../mocks/logics_mcp.go -package=mocks
//

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

import (
	context "context"
	sql "database/sql"
	reflect "reflect"

	interfaces "github.com/kweaver-ai/adp/execution-factory/operator-integration/server/interfaces"
	gomock "go.uber.org/mock/gomock"
)

// MockIMCPManageService is a mock of IMCPManageService interface.
type MockIMCPManageService struct {
	ctrl     *gomock.Controller
	recorder *MockIMCPManageServiceMockRecorder
	isgomock struct{}
}

// MockIMCPManageServiceMockRecorder is the mock recorder for MockIMCPManageService.
type MockIMCPManageServiceMockRecorder struct {
	mock *MockIMCPManageService
}

// NewMockIMCPManageService creates a new mock instance.
func NewMockIMCPManageService(ctrl *gomock.Controller) *MockIMCPManageService {
	mock := &MockIMCPManageService{ctrl: ctrl}
	mock.recorder = &MockIMCPManageServiceMockRecorder{mock}
	return mock
}

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

// AddMCPServer mocks base method.
func (m *MockIMCPManageService) AddMCPServer(ctx context.Context, req *interfaces.MCPServerAddRequest) (*interfaces.MCPServerAddResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddMCPServer", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerAddResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DebugTool mocks base method.
func (m *MockIMCPManageService) DebugTool(ctx context.Context, req *interfaces.MCPToolDebugRequest) (*interfaces.MCPToolDebugResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugTool", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPToolDebugResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetDetail mocks base method.
func (m *MockIMCPManageService) GetDetail(ctx context.Context, req *interfaces.MCPServerDetailRequest) (*interfaces.MCPServerDetailResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDetail", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerDetailResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ParseSSE mocks base method.
func (m *MockIMCPManageService) ParseSSE(ctx context.Context, req *interfaces.MCPParseSSERequest) (*interfaces.MCPParseSSEResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseSSE", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPParseSSEResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryPage mocks base method.
func (m *MockIMCPManageService) QueryPage(ctx context.Context, req *interfaces.MCPServerListRequest) (*interfaces.MCPServerListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryPage", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateMCPServer mocks base method.
func (m *MockIMCPManageService) UpdateMCPServer(ctx context.Context, req *interfaces.MCPServerUpdateRequest) (*interfaces.MCPServerUpdateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMCPServer", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerUpdateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateMCPStatus mocks base method.
func (m *MockIMCPManageService) UpdateMCPStatus(ctx context.Context, req *interfaces.UpdateMCPStatusRequest) (*interfaces.UpdateMCPStatusResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMCPStatus", ctx, req)
	ret0, _ := ret[0].(*interfaces.UpdateMCPStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockIMCPReleaseService is a mock of IMCPReleaseService interface.
type MockIMCPReleaseService struct {
	ctrl     *gomock.Controller
	recorder *MockIMCPReleaseServiceMockRecorder
	isgomock struct{}
}

// MockIMCPReleaseServiceMockRecorder is the mock recorder for MockIMCPReleaseService.
type MockIMCPReleaseServiceMockRecorder struct {
	mock *MockIMCPReleaseService
}

// NewMockIMCPReleaseService creates a new mock instance.
func NewMockIMCPReleaseService(ctrl *gomock.Controller) *MockIMCPReleaseService {
	mock := &MockIMCPReleaseService{ctrl: ctrl}
	mock.recorder = &MockIMCPReleaseServiceMockRecorder{mock}
	return mock
}

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

// GetReleaseDetail mocks base method.
func (m *MockIMCPReleaseService) GetReleaseDetail(ctx context.Context, req *interfaces.MCPServerReleaseDetailRequest) (*interfaces.MCPServerReleaseDetailResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReleaseDetail", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerReleaseDetailResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryRelease mocks base method.
func (m *MockIMCPReleaseService) QueryRelease(ctx context.Context, req *interfaces.MCPServerReleaseListRequest) (*interfaces.MCPServerReleaseListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryRelease", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerReleaseListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockIMCPExecuteService is a mock of IMCPExecuteService interface.
type MockIMCPExecuteService struct {
	ctrl     *gomock.Controller
	recorder *MockIMCPExecuteServiceMockRecorder
	isgomock struct{}
}

// MockIMCPExecuteServiceMockRecorder is the mock recorder for MockIMCPExecuteService.
type MockIMCPExecuteServiceMockRecorder struct {
	mock *MockIMCPExecuteService
}

// NewMockIMCPExecuteService creates a new mock instance.
func NewMockIMCPExecuteService(ctrl *gomock.Controller) *MockIMCPExecuteService {
	mock := &MockIMCPExecuteService{ctrl: ctrl}
	mock.recorder = &MockIMCPExecuteServiceMockRecorder{mock}
	return mock
}

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

// CallMCPTool mocks base method.
func (m *MockIMCPExecuteService) CallMCPTool(ctx context.Context, req *interfaces.MCPProxyCallToolRequest) (*interfaces.MCPProxyCallToolResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CallMCPTool", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPProxyCallToolResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMCPTools mocks base method.
func (m *MockIMCPExecuteService) GetMCPTools(ctx context.Context, req *interfaces.MCPProxyToolListRequest) (*interfaces.MCPProxyToolListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPTools", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPProxyToolListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockIMCPBuiltinService is a mock of IMCPBuiltinService interface.
type MockIMCPBuiltinService struct {
	ctrl     *gomock.Controller
	recorder *MockIMCPBuiltinServiceMockRecorder
	isgomock struct{}
}

// MockIMCPBuiltinServiceMockRecorder is the mock recorder for MockIMCPBuiltinService.
type MockIMCPBuiltinServiceMockRecorder struct {
	mock *MockIMCPBuiltinService
}

// NewMockIMCPBuiltinService creates a new mock instance.
func NewMockIMCPBuiltinService(ctrl *gomock.Controller) *MockIMCPBuiltinService {
	mock := &MockIMCPBuiltinService{ctrl: ctrl}
	mock.recorder = &MockIMCPBuiltinServiceMockRecorder{mock}
	return mock
}

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

// RegisterBuiltinMCPServer mocks base method.
func (m *MockIMCPBuiltinService) RegisterBuiltinMCPServer(ctx context.Context, req *interfaces.MCPBuiltinRegisterRequest) (*interfaces.MCPBuiltinRegisterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterBuiltinMCPServer", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPBuiltinRegisterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockIMCPService is a mock of IMCPService interface.
type MockIMCPService struct {
	ctrl     *gomock.Controller
	recorder *MockIMCPServiceMockRecorder
	isgomock struct{}
}

// MockIMCPServiceMockRecorder is the mock recorder for MockIMCPService.
type MockIMCPServiceMockRecorder struct {
	mock *MockIMCPService
}

// NewMockIMCPService creates a new mock instance.
func NewMockIMCPService(ctrl *gomock.Controller) *MockIMCPService {
	mock := &MockIMCPService{ctrl: ctrl}
	mock.recorder = &MockIMCPServiceMockRecorder{mock}
	return mock
}

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

// AddMCPServer mocks base method.
func (m *MockIMCPService) AddMCPServer(ctx context.Context, req *interfaces.MCPServerAddRequest) (*interfaces.MCPServerAddResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddMCPServer", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerAddResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CallMCPTool mocks base method.
func (m *MockIMCPService) CallMCPTool(ctx context.Context, req *interfaces.MCPProxyCallToolRequest) (*interfaces.MCPProxyCallToolResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CallMCPTool", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPProxyCallToolResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DebugTool mocks base method.
func (m *MockIMCPService) DebugTool(ctx context.Context, req *interfaces.MCPToolDebugRequest) (*interfaces.MCPToolDebugResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugTool", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPToolDebugResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ExecuteTool mocks base method.
func (m *MockIMCPService) ExecuteTool(ctx context.Context, mcpToolID string, params interfaces.HTTPRequestParams) (*interfaces.HTTPResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteTool", ctx, mcpToolID, params)
	ret0, _ := ret[0].(*interfaces.HTTPResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Export mocks base method.
func (m *MockIMCPService) Export(ctx context.Context, req *interfaces.ExportReq) (*interfaces.ComponentImpexConfigModel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Export", ctx, req)
	ret0, _ := ret[0].(*interfaces.ComponentImpexConfigModel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDetail mocks base method.
func (m *MockIMCPService) GetDetail(ctx context.Context, req *interfaces.MCPServerDetailRequest) (*interfaces.MCPServerDetailResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDetail", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerDetailResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMCPInstanceConfig mocks base method.
func (m *MockIMCPService) GetMCPInstanceConfig(ctx context.Context, mcpID string, mode interfaces.MCPMode) (*interfaces.MCPInstancConfigInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPInstanceConfig", ctx, mcpID, mode)
	ret0, _ := ret[0].(*interfaces.MCPInstancConfigInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMCPInstanceConfig indicates an expected call of GetMCPInstanceConfig.
func (mr *MockIMCPServiceMockRecorder) GetMCPInstanceConfig(ctx, mcpID, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMCPInstanceConfig", reflect.TypeOf((*MockIMCPService)(nil).GetMCPInstanceConfig), ctx, mcpID, mode)
}

// GetMCPTools mocks base method.
func (m *MockIMCPService) GetMCPTools(ctx context.Context, req *interfaces.MCPProxyToolListRequest) (*interfaces.MCPProxyToolListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPTools", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPProxyToolListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReleaseDetail mocks base method.
func (m *MockIMCPService) GetReleaseDetail(ctx context.Context, req *interfaces.MCPServerReleaseDetailRequest) (*interfaces.MCPServerReleaseDetailResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReleaseDetail", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerReleaseDetailResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Import mocks base method.
func (m *MockIMCPService) Import(ctx context.Context, tx *sql.Tx, mode interfaces.ImportType, data *interfaces.ComponentImpexConfigModel, userID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Import", ctx, tx, mode, data, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Import indicates an expected call of Import.
func (mr *MockIMCPServiceMockRecorder) Import(ctx, tx, mode, data, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Import", reflect.TypeOf((*MockIMCPService)(nil).Import), ctx, tx, mode, data, userID)
}

// ParseSSE mocks base method.
func (m *MockIMCPService) ParseSSE(ctx context.Context, req *interfaces.MCPParseSSERequest) (*interfaces.MCPParseSSEResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseSSE", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPParseSSEResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryPage mocks base method.
func (m *MockIMCPService) QueryPage(ctx context.Context, req *interfaces.MCPServerListRequest) (*interfaces.MCPServerListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryPage", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryRelease mocks base method.
func (m *MockIMCPService) QueryRelease(ctx context.Context, req *interfaces.MCPServerReleaseListRequest) (*interfaces.MCPServerReleaseListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryRelease", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerReleaseListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// RegisterBuiltinMCPServer mocks base method.
func (m *MockIMCPService) RegisterBuiltinMCPServer(ctx context.Context, req *interfaces.MCPBuiltinRegisterRequest) (*interfaces.MCPBuiltinRegisterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterBuiltinMCPServer", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPBuiltinRegisterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UpdateMCPServer mocks base method.
func (m *MockIMCPService) UpdateMCPServer(ctx context.Context, req *interfaces.MCPServerUpdateRequest) (*interfaces.MCPServerUpdateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMCPServer", ctx, req)
	ret0, _ := ret[0].(*interfaces.MCPServerUpdateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateMCPStatus mocks base method.
func (m *MockIMCPService) UpdateMCPStatus(ctx context.Context, req *interfaces.UpdateMCPStatusRequest) (*interfaces.UpdateMCPStatusResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMCPStatus", ctx, req)
	ret0, _ := ret[0].(*interfaces.UpdateMCPStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockIMCPImpexService is a mock of IMCPImpexService interface.
type MockIMCPImpexService struct {
	ctrl     *gomock.Controller
	recorder *MockIMCPImpexServiceMockRecorder
	isgomock struct{}
}

// MockIMCPImpexServiceMockRecorder is the mock recorder for MockIMCPImpexService.
type MockIMCPImpexServiceMockRecorder struct {
	mock *MockIMCPImpexService
}

// NewMockIMCPImpexService creates a new mock instance.
func NewMockIMCPImpexService(ctrl *gomock.Controller) *MockIMCPImpexService {
	mock := &MockIMCPImpexService{ctrl: ctrl}
	mock.recorder = &MockIMCPImpexServiceMockRecorder{mock}
	return mock
}

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

// Export mocks base method.
func (m *MockIMCPImpexService) Export(ctx context.Context, req *interfaces.ExportReq) (*interfaces.ComponentImpexConfigModel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Export", ctx, req)
	ret0, _ := ret[0].(*interfaces.ComponentImpexConfigModel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Import mocks base method.
func (m *MockIMCPImpexService) Import(ctx context.Context, tx *sql.Tx, mode interfaces.ImportType, data *interfaces.ComponentImpexConfigModel, userID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Import", ctx, tx, mode, data, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Import indicates an expected call of Import.
func (mr *MockIMCPImpexServiceMockRecorder) Import(ctx, tx, mode, data, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Import", reflect.TypeOf((*MockIMCPImpexService)(nil).Import), ctx, tx, mode, data, userID)
}

// MockIMCPToolExecutor is a mock of IMCPToolExecutor interface.
type MockIMCPToolExecutor struct {
	ctrl     *gomock.Controller
	recorder *MockIMCPToolExecutorMockRecorder
	isgomock struct{}
}

// MockIMCPToolExecutorMockRecorder is the mock recorder for MockIMCPToolExecutor.
type MockIMCPToolExecutorMockRecorder struct {
	mock *MockIMCPToolExecutor
}

// NewMockIMCPToolExecutor creates a new mock instance.
func NewMockIMCPToolExecutor(ctrl *gomock.Controller) *MockIMCPToolExecutor {
	mock := &MockIMCPToolExecutor{ctrl: ctrl}
	mock.recorder = &MockIMCPToolExecutorMockRecorder{mock}
	return mock
}

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

// ExecuteTool mocks base method.
func (m *MockIMCPToolExecutor) ExecuteTool(ctx context.Context, mcpToolID string, params interfaces.HTTPRequestParams) (*interfaces.HTTPResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteTool", ctx, mcpToolID, params)
	ret0, _ := ret[0].(*interfaces.HTTPResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockIMCPInstancConfig is a mock of IMCPInstancConfig interface.
type MockIMCPInstancConfig struct {
	ctrl     *gomock.Controller
	recorder *MockIMCPInstancConfigMockRecorder
	isgomock struct{}
}

// MockIMCPInstancConfigMockRecorder is the mock recorder for MockIMCPInstancConfig.
type MockIMCPInstancConfigMockRecorder struct {
	mock *MockIMCPInstancConfig
}

// NewMockIMCPInstancConfig creates a new mock instance.
func NewMockIMCPInstancConfig(ctrl *gomock.Controller) *MockIMCPInstancConfig {
	mock := &MockIMCPInstancConfig{ctrl: ctrl}
	mock.recorder = &MockIMCPInstancConfigMockRecorder{mock}
	return mock
}

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

// GetMCPInstanceConfig mocks base method.
func (m *MockIMCPInstancConfig) GetMCPInstanceConfig(ctx context.Context, mcpID string, mode interfaces.MCPMode) (*interfaces.MCPInstancConfigInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPInstanceConfig", ctx, mcpID, mode)
	ret0, _ := ret[0].(*interfaces.MCPInstancConfigInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMCPInstanceConfig indicates an expected call of GetMCPInstanceConfig.
func (mr *MockIMCPInstancConfigMockRecorder) GetMCPInstanceConfig(ctx, mcpID, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMCPInstanceConfig", reflect.TypeOf((*MockIMCPInstancConfig)(nil).GetMCPInstanceConfig), ctx, mcpID, mode)
}
