// Code generated by MockGen. DO NOT EDIT.
// Source: server/interfaces/logics_metadata.go
//
// Generated by this command:
//
//	mockgen -source=server/interfaces/logics_metadata.go -destination=server/mocks/mock_metadata_service.go -package=mocks IMetadataService
//

// 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"
	model "github.com/kweaver-ai/adp/execution-factory/operator-integration/server/interfaces/model"
	gomock "go.uber.org/mock/gomock"
)

// MockIMetadataService is a mock of IMetadataService interface.
type MockIMetadataService struct {
	ctrl     *gomock.Controller
	recorder *MockIMetadataServiceMockRecorder
	isgomock struct{}
}

// MockIMetadataServiceMockRecorder is the mock recorder for MockIMetadataService.
type MockIMetadataServiceMockRecorder struct {
	mock *MockIMetadataService
}

// NewMockIMetadataService creates a new mock instance.
func NewMockIMetadataService(ctrl *gomock.Controller) *MockIMetadataService {
	mock := &MockIMetadataService{ctrl: ctrl}
	mock.recorder = &MockIMetadataServiceMockRecorder{mock}
	return mock
}

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

// BatchDeleteMetadata mocks base method.
func (m *MockIMetadataService) BatchDeleteMetadata(ctx context.Context, tx *sql.Tx, metadataType interfaces.MetadataType, versions []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchDeleteMetadata", ctx, tx, metadataType, versions)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchDeleteMetadata indicates an expected call of BatchDeleteMetadata.
func (mr *MockIMetadataServiceMockRecorder) BatchDeleteMetadata(ctx, tx, metadataType, versions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteMetadata", reflect.TypeOf((*MockIMetadataService)(nil).BatchDeleteMetadata), ctx, tx, metadataType, versions)
}

// BatchGetMetadata mocks base method.
func (m *MockIMetadataService) BatchGetMetadata(ctx context.Context, apiVersions, funcVersions []string) ([]interfaces.IMetadataDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetMetadata", ctx, apiVersions, funcVersions)
	ret0, _ := ret[0].([]interfaces.IMetadataDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetMetadata indicates an expected call of BatchGetMetadata.
func (mr *MockIMetadataServiceMockRecorder) BatchGetMetadata(ctx, apiVersions, funcVersions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetMetadata", reflect.TypeOf((*MockIMetadataService)(nil).BatchGetMetadata), ctx, apiVersions, funcVersions)
}

// BatchGetMetadataBySourceIDs mocks base method.
func (m *MockIMetadataService) BatchGetMetadataBySourceIDs(ctx context.Context, sourceMap map[model.SourceType][]string) (map[string]interfaces.IMetadataDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetMetadataBySourceIDs", ctx, sourceMap)
	ret0, _ := ret[0].(map[string]interfaces.IMetadataDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetMetadataBySourceIDs indicates an expected call of BatchGetMetadataBySourceIDs.
func (mr *MockIMetadataServiceMockRecorder) BatchGetMetadataBySourceIDs(ctx, sourceMap any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetMetadataBySourceIDs", reflect.TypeOf((*MockIMetadataService)(nil).BatchGetMetadataBySourceIDs), ctx, sourceMap)
}

// BatchRegisterMetadata mocks base method.
func (m *MockIMetadataService) BatchRegisterMetadata(ctx context.Context, tx *sql.Tx, metadatas []interfaces.IMetadataDB) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchRegisterMetadata", ctx, tx, metadatas)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchRegisterMetadata indicates an expected call of BatchRegisterMetadata.
func (mr *MockIMetadataServiceMockRecorder) BatchRegisterMetadata(ctx, tx, metadatas any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchRegisterMetadata", reflect.TypeOf((*MockIMetadataService)(nil).BatchRegisterMetadata), ctx, tx, metadatas)
}

// CheckMetadataExists mocks base method.
func (m *MockIMetadataService) CheckMetadataExists(ctx context.Context, metadataType interfaces.MetadataType, version string) (bool, interfaces.IMetadataDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckMetadataExists", ctx, metadataType, version)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(interfaces.IMetadataDB)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CheckMetadataExists indicates an expected call of CheckMetadataExists.
func (mr *MockIMetadataServiceMockRecorder) CheckMetadataExists(ctx, metadataType, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckMetadataExists", reflect.TypeOf((*MockIMetadataService)(nil).CheckMetadataExists), ctx, metadataType, version)
}

// GetMetadataBySource mocks base method.
func (m *MockIMetadataService) GetMetadataBySource(ctx context.Context, sourceID string, sourceType model.SourceType) (bool, interfaces.IMetadataDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetadataBySource", ctx, sourceID, sourceType)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(interfaces.IMetadataDB)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetMetadataByVersion mocks base method.
func (m *MockIMetadataService) GetMetadataByVersion(ctx context.Context, metadataType interfaces.MetadataType, version string) (interfaces.IMetadataDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetadataByVersion", ctx, metadataType, version)
	ret0, _ := ret[0].(interfaces.IMetadataDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetadataByVersion indicates an expected call of GetMetadataByVersion.
func (mr *MockIMetadataServiceMockRecorder) GetMetadataByVersion(ctx, metadataType, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadataByVersion", reflect.TypeOf((*MockIMetadataService)(nil).GetMetadataByVersion), ctx, metadataType, version)
}

// ParseMetadata mocks base method.
func (m *MockIMetadataService) ParseMetadata(ctx context.Context, metadataType interfaces.MetadataType, input any) ([]interfaces.IMetadataDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseMetadata", ctx, metadataType, input)
	ret0, _ := ret[0].([]interfaces.IMetadataDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseMetadata indicates an expected call of ParseMetadata.
func (mr *MockIMetadataServiceMockRecorder) ParseMetadata(ctx, metadataType, input any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseMetadata", reflect.TypeOf((*MockIMetadataService)(nil).ParseMetadata), ctx, metadataType, input)
}

// ParseRawContent mocks base method.
func (m *MockIMetadataService) ParseRawContent(ctx context.Context, metadataType interfaces.MetadataType, input any) (any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseRawContent", ctx, metadataType, input)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseRawContent indicates an expected call of ParseRawContent.
func (mr *MockIMetadataServiceMockRecorder) ParseRawContent(ctx, metadataType, input any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseRawContent", reflect.TypeOf((*MockIMetadataService)(nil).ParseRawContent), ctx, metadataType, input)
}

// RegisterMetadata mocks base method.
func (m *MockIMetadataService) RegisterMetadata(ctx context.Context, tx *sql.Tx, metadata interfaces.IMetadataDB) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterMetadata", ctx, tx, metadata)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterMetadata indicates an expected call of RegisterMetadata.
func (mr *MockIMetadataServiceMockRecorder) RegisterMetadata(ctx, tx, metadata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterMetadata", reflect.TypeOf((*MockIMetadataService)(nil).RegisterMetadata), ctx, tx, metadata)
}

// UpdateMetadata mocks base method.
func (m *MockIMetadataService) UpdateMetadata(ctx context.Context, tx *sql.Tx, metadata interfaces.IMetadataDB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMetadata", ctx, tx, metadata)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateMetadata indicates an expected call of UpdateMetadata.
func (mr *MockIMetadataServiceMockRecorder) UpdateMetadata(ctx, tx, metadata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMetadata", reflect.TypeOf((*MockIMetadataService)(nil).UpdateMetadata), ctx, tx, metadata)
}

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

// ValidateMetadata indicates an expected call of ValidateMetadata.
func (mr *MockIMetadataServiceMockRecorder) ValidateMetadata(ctx, metadata any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateMetadata", reflect.TypeOf((*MockIMetadataService)(nil).ValidateMetadata), ctx, metadata)
}
