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

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

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

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

// MockIToolboxDB is a mock of IToolboxDB interface.
type MockIToolboxDB struct {
	ctrl     *gomock.Controller
	recorder *MockIToolboxDBMockRecorder
	isgomock struct{}
}

// MockIToolboxDBMockRecorder is the mock recorder for MockIToolboxDB.
type MockIToolboxDBMockRecorder struct {
	mock *MockIToolboxDB
}

// NewMockIToolboxDB creates a new mock instance.
func NewMockIToolboxDB(ctrl *gomock.Controller) *MockIToolboxDB {
	mock := &MockIToolboxDB{ctrl: ctrl}
	mock.recorder = &MockIToolboxDBMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// InsertToolBox indicates an expected call of InsertToolBox.
func (mr *MockIToolboxDBMockRecorder) InsertToolBox(ctx, tx, toolbox any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertToolBox", reflect.TypeOf((*MockIToolboxDB)(nil).InsertToolBox), ctx, tx, toolbox)
}

// SelectListByBoxIDs mocks base method.
func (m *MockIToolboxDB) SelectListByBoxIDs(ctx context.Context, boxIDs []string, status ...string) ([]*model.ToolboxDB, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, boxIDs}
	for _, a := range status {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SelectListByBoxIDs", varargs...)
	ret0, _ := ret[0].([]*model.ToolboxDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectListByBoxIDs indicates an expected call of SelectListByBoxIDs.
func (mr *MockIToolboxDBMockRecorder) SelectListByBoxIDs(ctx, boxIDs any, status ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, boxIDs}, status...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectListByBoxIDs", reflect.TypeOf((*MockIToolboxDB)(nil).SelectListByBoxIDs), varargs...)
}

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

// SelectListByBoxIDsFilter indicates an expected call of SelectListByBoxIDsFilter.
func (mr *MockIToolboxDBMockRecorder) SelectListByBoxIDsFilter(ctx, boxIDs, status, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectListByBoxIDsFilter", reflect.TypeOf((*MockIToolboxDB)(nil).SelectListByBoxIDsFilter), ctx, boxIDs, status, filter)
}

// SelectListByNamesAndStatus mocks base method.
func (m *MockIToolboxDB) SelectListByNamesAndStatus(ctx context.Context, names []string, status ...string) ([]*model.ToolboxDB, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, names}
	for _, a := range status {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SelectListByNamesAndStatus", varargs...)
	ret0, _ := ret[0].([]*model.ToolboxDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectListByNamesAndStatus indicates an expected call of SelectListByNamesAndStatus.
func (mr *MockIToolboxDBMockRecorder) SelectListByNamesAndStatus(ctx, names any, status ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, names}, status...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectListByNamesAndStatus", reflect.TypeOf((*MockIToolboxDB)(nil).SelectListByNamesAndStatus), varargs...)
}

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

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

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

// SelectToolBoxByName indicates an expected call of SelectToolBoxByName.
func (mr *MockIToolboxDBMockRecorder) SelectToolBoxByName(ctx, name, status any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectToolBoxByName", reflect.TypeOf((*MockIToolboxDB)(nil).SelectToolBoxByName), ctx, name, status)
}

// SelectToolBoxList mocks base method.
func (m *MockIToolboxDB) SelectToolBoxList(ctx context.Context, filter map[string]any, sort *ormhelper.SortParams, cursor *ormhelper.CursorParams) ([]*model.ToolboxDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectToolBoxList", ctx, filter, sort, cursor)
	ret0, _ := ret[0].([]*model.ToolboxDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectToolBoxList indicates an expected call of SelectToolBoxList.
func (mr *MockIToolboxDBMockRecorder) SelectToolBoxList(ctx, filter, sort, cursor any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectToolBoxList", reflect.TypeOf((*MockIToolboxDB)(nil).SelectToolBoxList), ctx, filter, sort, cursor)
}

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

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

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

// UpdateToolBoxStatus indicates an expected call of UpdateToolBoxStatus.
func (mr *MockIToolboxDBMockRecorder) UpdateToolBoxStatus(ctx, tx, boxID, status, updateUser any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateToolBoxStatus", reflect.TypeOf((*MockIToolboxDB)(nil).UpdateToolBoxStatus), ctx, tx, boxID, status, updateUser)
}
