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

// MockOperatorManager is a mock of OperatorManager interface.
type MockOperatorManager struct {
	ctrl     *gomock.Controller
	recorder *MockOperatorManagerMockRecorder
	isgomock struct{}
}

// MockOperatorManagerMockRecorder is the mock recorder for MockOperatorManager.
type MockOperatorManagerMockRecorder struct {
	mock *MockOperatorManager
}

// NewMockOperatorManager creates a new mock instance.
func NewMockOperatorManager(ctrl *gomock.Controller) *MockOperatorManager {
	mock := &MockOperatorManager{ctrl: ctrl}
	mock.recorder = &MockOperatorManagerMockRecorder{mock}
	return mock
}

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

// CheckAddAsTool mocks base method.
func (m *MockOperatorManager) CheckAddAsTool(ctx context.Context, operatorID, userID string) (*interfaces.CheckAddAsToolResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAddAsTool", ctx, operatorID, userID)
	ret0, _ := ret[0].(*interfaces.CheckAddAsToolResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckAddAsTool indicates an expected call of CheckAddAsTool.
func (mr *MockOperatorManagerMockRecorder) CheckAddAsTool(ctx, operatorID, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAddAsTool", reflect.TypeOf((*MockOperatorManager)(nil).CheckAddAsTool), ctx, operatorID, userID)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Import mocks base method.
func (m *MockOperatorManager) Import(ctx context.Context, tx *sql.Tx, mode interfaces.ImportType, data *interfaces.OperatorImpexConfig, 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 *MockOperatorManagerMockRecorder) Import(ctx, tx, mode, data, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Import", reflect.TypeOf((*MockOperatorManager)(nil).Import), ctx, tx, mode, data, userID)
}

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

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

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

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

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

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

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

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

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

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

// RegisterOperatorByOpenAPI mocks base method.
func (m *MockOperatorManager) RegisterOperatorByOpenAPI(ctx context.Context, req *interfaces.OperatorRegisterReq, userID string) ([]*interfaces.OperatorRegisterResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterOperatorByOpenAPI", ctx, req, userID)
	ret0, _ := ret[0].([]*interfaces.OperatorRegisterResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateOperatorByOpenAPI mocks base method.
func (m *MockOperatorManager) UpdateOperatorByOpenAPI(ctx context.Context, req *interfaces.OperatorUpdateReq, userID string) ([]*interfaces.OperatorRegisterResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOperatorByOpenAPI", ctx, req, userID)
	ret0, _ := ret[0].([]*interfaces.OperatorRegisterResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockInternalOperatorManager is a mock of InternalOperatorManager interface.
type MockInternalOperatorManager struct {
	ctrl     *gomock.Controller
	recorder *MockInternalOperatorManagerMockRecorder
	isgomock struct{}
}

// MockInternalOperatorManagerMockRecorder is the mock recorder for MockInternalOperatorManager.
type MockInternalOperatorManagerMockRecorder struct {
	mock *MockInternalOperatorManager
}

// NewMockInternalOperatorManager creates a new mock instance.
func NewMockInternalOperatorManager(ctrl *gomock.Controller) *MockInternalOperatorManager {
	mock := &MockInternalOperatorManager{ctrl: ctrl}
	mock.recorder = &MockInternalOperatorManagerMockRecorder{mock}
	return mock
}

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

// CheckAddAsTool mocks base method.
func (m *MockInternalOperatorManager) CheckAddAsTool(ctx context.Context, operatorID, userID string) (*interfaces.CheckAddAsToolResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAddAsTool", ctx, operatorID, userID)
	ret0, _ := ret[0].(*interfaces.CheckAddAsToolResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckAddAsTool indicates an expected call of CheckAddAsTool.
func (mr *MockInternalOperatorManagerMockRecorder) CheckAddAsTool(ctx, operatorID, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAddAsTool", reflect.TypeOf((*MockInternalOperatorManager)(nil).CheckAddAsTool), ctx, operatorID, userID)
}
