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

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

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

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

// MockIToolDB is a mock of IToolDB interface.
type MockIToolDB struct {
	ctrl     *gomock.Controller
	recorder *MockIToolDBMockRecorder
	isgomock struct{}
}

// MockIToolDBMockRecorder is the mock recorder for MockIToolDB.
type MockIToolDBMockRecorder struct {
	mock *MockIToolDB
}

// NewMockIToolDB creates a new mock instance.
func NewMockIToolDB(ctrl *gomock.Controller) *MockIToolDB {
	mock := &MockIToolDB{ctrl: ctrl}
	mock.recorder = &MockIToolDBMockRecorder{mock}
	return mock
}

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

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

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

// DeleteBoxByIDAndTools mocks base method.
func (m *MockIToolDB) DeleteBoxByIDAndTools(ctx context.Context, tx *sql.Tx, boxID string, toolIDs []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBoxByIDAndTools", ctx, tx, boxID, toolIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBoxByIDAndTools indicates an expected call of DeleteBoxByIDAndTools.
func (mr *MockIToolDBMockRecorder) DeleteBoxByIDAndTools(ctx, tx, boxID, toolIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBoxByIDAndTools", reflect.TypeOf((*MockIToolDB)(nil).DeleteBoxByIDAndTools), ctx, tx, boxID, toolIDs)
}

// InsertTool mocks base method.
func (m *MockIToolDB) InsertTool(ctx context.Context, tx *sql.Tx, tool *model.ToolDB) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTool", ctx, tx, tool)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertTool indicates an expected call of InsertTool.
func (mr *MockIToolDBMockRecorder) InsertTool(ctx, tx, tool any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTool", reflect.TypeOf((*MockIToolDB)(nil).InsertTool), ctx, tx, tool)
}

// InsertTools mocks base method.
func (m *MockIToolDB) InsertTools(ctx context.Context, tx *sql.Tx, tools []*model.ToolDB) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTools", ctx, tx, tools)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertTools indicates an expected call of InsertTools.
func (mr *MockIToolDBMockRecorder) InsertTools(ctx, tx, tools any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTools", reflect.TypeOf((*MockIToolDB)(nil).InsertTools), ctx, tx, tools)
}

// SelectBoxToolByName mocks base method.
func (m *MockIToolDB) SelectBoxToolByName(ctx context.Context, boxID, name string) (bool, *model.ToolDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectBoxToolByName", ctx, boxID, name)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*model.ToolDB)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelectBoxToolByName indicates an expected call of SelectBoxToolByName.
func (mr *MockIToolDBMockRecorder) SelectBoxToolByName(ctx, boxID, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectBoxToolByName", reflect.TypeOf((*MockIToolDB)(nil).SelectBoxToolByName), ctx, boxID, name)
}

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

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

// SelectToolBoxByID mocks base method.
func (m *MockIToolDB) SelectToolBoxByID(ctx context.Context, boxID string, toolID []string) ([]*model.ToolDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectToolBoxByID", ctx, boxID, toolID)
	ret0, _ := ret[0].([]*model.ToolDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectToolBoxByID indicates an expected call of SelectToolBoxByID.
func (mr *MockIToolDBMockRecorder) SelectToolBoxByID(ctx, boxID, toolID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectToolBoxByID", reflect.TypeOf((*MockIToolDB)(nil).SelectToolBoxByID), ctx, boxID, toolID)
}

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

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

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

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

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

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

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

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

// SelectToolBySource mocks base method.
func (m *MockIToolDB) SelectToolBySource(ctx context.Context, sourceType model.SourceType, sourceID string) ([]*model.ToolDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectToolBySource", ctx, sourceType, sourceID)
	ret0, _ := ret[0].([]*model.ToolDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectToolBySource indicates an expected call of SelectToolBySource.
func (mr *MockIToolDBMockRecorder) SelectToolBySource(ctx, sourceType, sourceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectToolBySource", reflect.TypeOf((*MockIToolDB)(nil).SelectToolBySource), ctx, sourceType, sourceID)
}

// SelectToolLisByBoxID mocks base method.
func (m *MockIToolDB) SelectToolLisByBoxID(ctx context.Context, boxID string, filter map[string]any) ([]*model.ToolDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectToolLisByBoxID", ctx, boxID, filter)
	ret0, _ := ret[0].([]*model.ToolDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// UpdateTool mocks base method.
func (m *MockIToolDB) UpdateTool(ctx context.Context, tx *sql.Tx, tool *model.ToolDB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTool", ctx, tx, tool)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateToolStatus mocks base method.
func (m *MockIToolDB) UpdateToolStatus(ctx context.Context, tx *sql.Tx, toolID, status, userID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateToolStatus", ctx, tx, toolID, status, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateToolStatus indicates an expected call of UpdateToolStatus.
func (mr *MockIToolDBMockRecorder) UpdateToolStatus(ctx, tx, toolID, status, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateToolStatus", reflect.TypeOf((*MockIToolDB)(nil).UpdateToolStatus), ctx, tx, toolID, status, userID)
}
