// Code generated by MockGen. DO NOT EDIT.
// Source: ../interfaces/object_type_service.go
//
// Generated by this command:
//
//	mockgen -source ../interfaces/object_type_service.go -destination ../interfaces/mock/mock_object_type_service.go
//

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

import (
	interfaces "bkn-backend/interfaces"
	context "context"
	sql "database/sql"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockObjectTypeService is a mock of ObjectTypeService interface.
type MockObjectTypeService struct {
	ctrl     *gomock.Controller
	recorder *MockObjectTypeServiceMockRecorder
	isgomock struct{}
}

// MockObjectTypeServiceMockRecorder is the mock recorder for MockObjectTypeService.
type MockObjectTypeServiceMockRecorder struct {
	mock *MockObjectTypeService
}

// NewMockObjectTypeService creates a new mock instance.
func NewMockObjectTypeService(ctrl *gomock.Controller) *MockObjectTypeService {
	mock := &MockObjectTypeService{ctrl: ctrl}
	mock.recorder = &MockObjectTypeServiceMockRecorder{mock}
	return mock
}

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

// CheckObjectTypeExistByID mocks base method.
func (m *MockObjectTypeService) CheckObjectTypeExistByID(ctx context.Context, knID, branch, otID string) (string, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckObjectTypeExistByID", ctx, knID, branch, otID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckObjectTypeExistByID indicates an expected call of CheckObjectTypeExistByID.
func (mr *MockObjectTypeServiceMockRecorder) CheckObjectTypeExistByID(ctx, knID, branch, otID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckObjectTypeExistByID", reflect.TypeOf((*MockObjectTypeService)(nil).CheckObjectTypeExistByID), ctx, knID, branch, otID)
}

// CheckObjectTypeExistByName mocks base method.
func (m *MockObjectTypeService) CheckObjectTypeExistByName(ctx context.Context, knID, branch, otName string) (string, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckObjectTypeExistByName", ctx, knID, branch, otName)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckObjectTypeExistByName indicates an expected call of CheckObjectTypeExistByName.
func (mr *MockObjectTypeServiceMockRecorder) CheckObjectTypeExistByName(ctx, knID, branch, otName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckObjectTypeExistByName", reflect.TypeOf((*MockObjectTypeService)(nil).CheckObjectTypeExistByName), ctx, knID, branch, otName)
}

// CreateObjectTypes mocks base method.
func (m *MockObjectTypeService) CreateObjectTypes(ctx context.Context, tx *sql.Tx, objectTypes []*interfaces.ObjectType, mode string, needCreateConceptGroupRelation, strictMode bool) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateObjectTypes", ctx, tx, objectTypes, mode, needCreateConceptGroupRelation, strictMode)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateObjectTypes indicates an expected call of CreateObjectTypes.
func (mr *MockObjectTypeServiceMockRecorder) CreateObjectTypes(ctx, tx, objectTypes, mode, needCreateConceptGroupRelation, strictMode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateObjectTypes", reflect.TypeOf((*MockObjectTypeService)(nil).CreateObjectTypes), ctx, tx, objectTypes, mode, needCreateConceptGroupRelation, strictMode)
}

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

// DeleteObjectTypesByIDs indicates an expected call of DeleteObjectTypesByIDs.
func (mr *MockObjectTypeServiceMockRecorder) DeleteObjectTypesByIDs(ctx, tx, knID, branch, otIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTypesByIDs", reflect.TypeOf((*MockObjectTypeService)(nil).DeleteObjectTypesByIDs), ctx, tx, knID, branch, otIDs)
}

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

// DeleteObjectTypesByKnID indicates an expected call of DeleteObjectTypesByKnID.
func (mr *MockObjectTypeServiceMockRecorder) DeleteObjectTypesByKnID(ctx, tx, knID, branch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTypesByKnID", reflect.TypeOf((*MockObjectTypeService)(nil).DeleteObjectTypesByKnID), ctx, tx, knID, branch)
}

// GetAllObjectTypesByKnID mocks base method.
func (m *MockObjectTypeService) GetAllObjectTypesByKnID(ctx context.Context, knID, branch string) (map[string]*interfaces.ObjectType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllObjectTypesByKnID", ctx, knID, branch)
	ret0, _ := ret[0].(map[string]*interfaces.ObjectType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllObjectTypesByKnID indicates an expected call of GetAllObjectTypesByKnID.
func (mr *MockObjectTypeServiceMockRecorder) GetAllObjectTypesByKnID(ctx, knID, branch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllObjectTypesByKnID", reflect.TypeOf((*MockObjectTypeService)(nil).GetAllObjectTypesByKnID), ctx, knID, branch)
}

// GetObjectTypeByID mocks base method.
func (m *MockObjectTypeService) GetObjectTypeByID(ctx context.Context, tx *sql.Tx, knID, branch, otID string) (*interfaces.ObjectType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTypeByID", ctx, tx, knID, branch, otID)
	ret0, _ := ret[0].(*interfaces.ObjectType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTypeByID indicates an expected call of GetObjectTypeByID.
func (mr *MockObjectTypeServiceMockRecorder) GetObjectTypeByID(ctx, tx, knID, branch, otID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTypeByID", reflect.TypeOf((*MockObjectTypeService)(nil).GetObjectTypeByID), ctx, tx, knID, branch, otID)
}

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

// GetObjectTypeIDsByKnID indicates an expected call of GetObjectTypeIDsByKnID.
func (mr *MockObjectTypeServiceMockRecorder) GetObjectTypeIDsByKnID(ctx, knID, branch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTypeIDsByKnID", reflect.TypeOf((*MockObjectTypeService)(nil).GetObjectTypeIDsByKnID), ctx, knID, branch)
}

// GetObjectTypesByIDs mocks base method.
func (m *MockObjectTypeService) GetObjectTypesByIDs(ctx context.Context, tx *sql.Tx, knID, branch string, otIDs []string) ([]*interfaces.ObjectType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTypesByIDs", ctx, tx, knID, branch, otIDs)
	ret0, _ := ret[0].([]*interfaces.ObjectType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTypesByIDs indicates an expected call of GetObjectTypesByIDs.
func (mr *MockObjectTypeServiceMockRecorder) GetObjectTypesByIDs(ctx, tx, knID, branch, otIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTypesByIDs", reflect.TypeOf((*MockObjectTypeService)(nil).GetObjectTypesByIDs), ctx, tx, knID, branch, otIDs)
}

// GetObjectTypesMapByIDs mocks base method.
func (m *MockObjectTypeService) GetObjectTypesMapByIDs(ctx context.Context, knID, branch string, otIDs []string, needPropMap bool) (map[string]*interfaces.ObjectType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectTypesMapByIDs", ctx, knID, branch, otIDs, needPropMap)
	ret0, _ := ret[0].(map[string]*interfaces.ObjectType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectTypesMapByIDs indicates an expected call of GetObjectTypesMapByIDs.
func (mr *MockObjectTypeServiceMockRecorder) GetObjectTypesMapByIDs(ctx, knID, branch, otIDs, needPropMap any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTypesMapByIDs", reflect.TypeOf((*MockObjectTypeService)(nil).GetObjectTypesMapByIDs), ctx, knID, branch, otIDs, needPropMap)
}

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

// InsertDatasetData indicates an expected call of InsertDatasetData.
func (mr *MockObjectTypeServiceMockRecorder) InsertDatasetData(ctx, objectTypes any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertDatasetData", reflect.TypeOf((*MockObjectTypeService)(nil).InsertDatasetData), ctx, objectTypes)
}

// ListObjectTypes mocks base method.
func (m *MockObjectTypeService) ListObjectTypes(ctx context.Context, tx *sql.Tx, query interfaces.ObjectTypesQueryParams) ([]*interfaces.ObjectType, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListObjectTypes", ctx, tx, query)
	ret0, _ := ret[0].([]*interfaces.ObjectType)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListObjectTypes indicates an expected call of ListObjectTypes.
func (mr *MockObjectTypeServiceMockRecorder) ListObjectTypes(ctx, tx, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectTypes", reflect.TypeOf((*MockObjectTypeService)(nil).ListObjectTypes), ctx, tx, query)
}

// SearchObjectTypes mocks base method.
func (m *MockObjectTypeService) SearchObjectTypes(ctx context.Context, query *interfaces.ConceptsQuery) (interfaces.ObjectTypes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchObjectTypes", ctx, query)
	ret0, _ := ret[0].(interfaces.ObjectTypes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchObjectTypes indicates an expected call of SearchObjectTypes.
func (mr *MockObjectTypeServiceMockRecorder) SearchObjectTypes(ctx, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchObjectTypes", reflect.TypeOf((*MockObjectTypeService)(nil).SearchObjectTypes), ctx, query)
}

// UpdateDataProperties mocks base method.
func (m *MockObjectTypeService) UpdateDataProperties(ctx context.Context, objectType *interfaces.ObjectType, dataProperties []*interfaces.DataProperty, strictMode bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataProperties", ctx, objectType, dataProperties, strictMode)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDataProperties indicates an expected call of UpdateDataProperties.
func (mr *MockObjectTypeServiceMockRecorder) UpdateDataProperties(ctx, objectType, dataProperties, strictMode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDataProperties", reflect.TypeOf((*MockObjectTypeService)(nil).UpdateDataProperties), ctx, objectType, dataProperties, strictMode)
}

// UpdateObjectType mocks base method.
func (m *MockObjectTypeService) UpdateObjectType(ctx context.Context, tx *sql.Tx, objectType *interfaces.ObjectType, strictMode bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateObjectType", ctx, tx, objectType, strictMode)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateObjectType indicates an expected call of UpdateObjectType.
func (mr *MockObjectTypeServiceMockRecorder) UpdateObjectType(ctx, tx, objectType, strictMode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateObjectType", reflect.TypeOf((*MockObjectTypeService)(nil).UpdateObjectType), ctx, tx, objectType, strictMode)
}

// ValidateObjectTypes mocks base method.
func (m *MockObjectTypeService) ValidateObjectTypes(ctx context.Context, knID, branch string, objectTypes []*interfaces.ObjectType, strictMode bool, batch *interfaces.BatchIDIndex, mode string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateObjectTypes", ctx, knID, branch, objectTypes, strictMode, batch, mode)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateObjectTypes indicates an expected call of ValidateObjectTypes.
func (mr *MockObjectTypeServiceMockRecorder) ValidateObjectTypes(ctx, knID, branch, objectTypes, strictMode, batch, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateObjectTypes", reflect.TypeOf((*MockObjectTypeService)(nil).ValidateObjectTypes), ctx, knID, branch, objectTypes, strictMode, batch, mode)
}
