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

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

import (
	context "context"
	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"
)

// MockSkillRegistry is a mock of SkillRegistry interface.
type MockSkillRegistry struct {
	ctrl     *gomock.Controller
	recorder *MockSkillRegistryMockRecorder
	isgomock struct{}
}

// MockSkillRegistryMockRecorder is the mock recorder for MockSkillRegistry.
type MockSkillRegistryMockRecorder struct {
	mock *MockSkillRegistry
}

// NewMockSkillRegistry creates a new mock instance.
func NewMockSkillRegistry(ctrl *gomock.Controller) *MockSkillRegistry {
	mock := &MockSkillRegistry{ctrl: ctrl}
	mock.recorder = &MockSkillRegistryMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockSkillMarket is a mock of SkillMarket interface.
type MockSkillMarket struct {
	ctrl     *gomock.Controller
	recorder *MockSkillMarketMockRecorder
	isgomock struct{}
}

// MockSkillMarketMockRecorder is the mock recorder for MockSkillMarket.
type MockSkillMarketMockRecorder struct {
	mock *MockSkillMarket
}

// NewMockSkillMarket creates a new mock instance.
func NewMockSkillMarket(ctrl *gomock.Controller) *MockSkillMarket {
	mock := &MockSkillMarket{ctrl: ctrl}
	mock.recorder = &MockSkillMarketMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockSkillReader is a mock of SkillReader interface.
type MockSkillReader struct {
	ctrl     *gomock.Controller
	recorder *MockSkillReaderMockRecorder
	isgomock struct{}
}

// MockSkillReaderMockRecorder is the mock recorder for MockSkillReader.
type MockSkillReaderMockRecorder struct {
	mock *MockSkillReader
}

// NewMockSkillReader creates a new mock instance.
func NewMockSkillReader(ctrl *gomock.Controller) *MockSkillReader {
	mock := &MockSkillReader{ctrl: ctrl}
	mock.recorder = &MockSkillReaderMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockSkillIndexBuildService is a mock of SkillIndexBuildService interface.
type MockSkillIndexBuildService struct {
	ctrl     *gomock.Controller
	recorder *MockSkillIndexBuildServiceMockRecorder
	isgomock struct{}
}

// MockSkillIndexBuildServiceMockRecorder is the mock recorder for MockSkillIndexBuildService.
type MockSkillIndexBuildServiceMockRecorder struct {
	mock *MockSkillIndexBuildService
}

// NewMockSkillIndexBuildService creates a new mock instance.
func NewMockSkillIndexBuildService(ctrl *gomock.Controller) *MockSkillIndexBuildService {
	mock := &MockSkillIndexBuildService{ctrl: ctrl}
	mock.recorder = &MockSkillIndexBuildServiceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockSkillIndexSyncService is a mock of SkillIndexSyncService interface.
type MockSkillIndexSyncService struct {
	ctrl     *gomock.Controller
	recorder *MockSkillIndexSyncServiceMockRecorder
	isgomock struct{}
}

// MockSkillIndexSyncServiceMockRecorder is the mock recorder for MockSkillIndexSyncService.
type MockSkillIndexSyncServiceMockRecorder struct {
	mock *MockSkillIndexSyncService
}

// NewMockSkillIndexSyncService creates a new mock instance.
func NewMockSkillIndexSyncService(ctrl *gomock.Controller) *MockSkillIndexSyncService {
	mock := &MockSkillIndexSyncService{ctrl: ctrl}
	mock.recorder = &MockSkillIndexSyncServiceMockRecorder{mock}
	return mock
}

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

// DeleteSkill mocks base method.
func (m *MockSkillIndexSyncService) DeleteSkill(ctx context.Context, skillID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSkill", ctx, skillID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSkill indicates an expected call of DeleteSkill.
func (mr *MockSkillIndexSyncServiceMockRecorder) DeleteSkill(ctx, skillID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSkill", reflect.TypeOf((*MockSkillIndexSyncService)(nil).DeleteSkill), ctx, skillID)
}

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

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

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

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

// UpdateSkill mocks base method.
func (m *MockSkillIndexSyncService) UpdateSkill(ctx context.Context, skill *model.SkillRepositoryDB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSkill", ctx, skill)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSkill indicates an expected call of UpdateSkill.
func (mr *MockSkillIndexSyncServiceMockRecorder) UpdateSkill(ctx, skill any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSkill", reflect.TypeOf((*MockSkillIndexSyncService)(nil).UpdateSkill), ctx, skill)
}

// UpsertSkill mocks base method.
func (m *MockSkillIndexSyncService) UpsertSkill(ctx context.Context, skill *model.SkillRepositoryDB) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertSkill", ctx, skill)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertSkill indicates an expected call of UpsertSkill.
func (mr *MockSkillIndexSyncServiceMockRecorder) UpsertSkill(ctx, skill any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertSkill", reflect.TypeOf((*MockSkillIndexSyncService)(nil).UpsertSkill), ctx, skill)
}
