// Code generated by MockGen. DO NOT EDIT.
// Source: logics_toolbox.go
//
// Generated by this command:
//
//	mockgen -source=logics_toolbox.go -destination=../mocks/toolbox.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"
)

// MockIToolService is a mock of IToolService interface.
type MockIToolService struct {
	ctrl     *gomock.Controller
	recorder *MockIToolServiceMockRecorder
	isgomock struct{}
}

// MockIToolServiceMockRecorder is the mock recorder for MockIToolService.
type MockIToolServiceMockRecorder struct {
	mock *MockIToolService
}

// NewMockIToolService creates a new mock instance.
func NewMockIToolService(ctrl *gomock.Controller) *MockIToolService {
	mock := &MockIToolService{ctrl: ctrl}
	mock.recorder = &MockIToolServiceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Export mocks base method.
func (m *MockIToolService) 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 *MockIToolServiceMockRecorder) Export(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Export", reflect.TypeOf((*MockIToolService)(nil).Export), ctx, req)
}

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

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

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

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

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

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

// GetToolBox mocks base method.
func (m *MockIToolService) GetToolBox(ctx context.Context, req *interfaces.GetToolBoxReq, isMarket bool) (*interfaces.ToolBoxToolInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetToolBox", ctx, req, isMarket)
	ret0, _ := ret[0].(*interfaces.ToolBoxToolInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Import mocks base method.
func (m *MockIToolService) 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 *MockIToolServiceMockRecorder) Import(ctx, tx, mode, data, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Import", reflect.TypeOf((*MockIToolService)(nil).Import), ctx, tx, mode, data, userID)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockToolBoxEventHandler is a mock of ToolBoxEventHandler interface.
type MockToolBoxEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockToolBoxEventHandlerMockRecorder
	isgomock struct{}
}

// MockToolBoxEventHandlerMockRecorder is the mock recorder for MockToolBoxEventHandler.
type MockToolBoxEventHandlerMockRecorder struct {
	mock *MockToolBoxEventHandler
}

// NewMockToolBoxEventHandler creates a new mock instance.
func NewMockToolBoxEventHandler(ctrl *gomock.Controller) *MockToolBoxEventHandler {
	mock := &MockToolBoxEventHandler{ctrl: ctrl}
	mock.recorder = &MockToolBoxEventHandlerMockRecorder{mock}
	return mock
}

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

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

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