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

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

import (
	context "context"
	reflect "reflect"

	v0 "github.com/modelcontextprotocol/registry/pkg/api/v0"
	service "github.com/stacklok/toolhive-registry-server/internal/service"
	gomock "go.uber.org/mock/gomock"
)

// MockRegistryService is a mock of RegistryService interface.
type MockRegistryService struct {
	ctrl     *gomock.Controller
	recorder *MockRegistryServiceMockRecorder
	isgomock struct{}
}

// MockRegistryServiceMockRecorder is the mock recorder for MockRegistryService.
type MockRegistryServiceMockRecorder struct {
	mock *MockRegistryService
}

// NewMockRegistryService creates a new mock instance.
func NewMockRegistryService(ctrl *gomock.Controller) *MockRegistryService {
	mock := &MockRegistryService{ctrl: ctrl}
	mock.recorder = &MockRegistryServiceMockRecorder{mock}
	return mock
}

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

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

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

// CreateRegistry mocks base method.
func (m *MockRegistryService) CreateRegistry(ctx context.Context, name string, req *service.RegistryCreateRequest) (*service.RegistryInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRegistry", ctx, name, req)
	ret0, _ := ret[0].(*service.RegistryInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSource mocks base method.
func (m *MockRegistryService) CreateSource(ctx context.Context, name string, req *service.SourceCreateRequest) (*service.SourceInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSource", ctx, name, req)
	ret0, _ := ret[0].(*service.SourceInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// DeleteServerVersion mocks base method.
func (m *MockRegistryService) DeleteServerVersion(ctx context.Context, opts ...service.Option) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteServerVersion", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteServerVersion indicates an expected call of DeleteServerVersion.
func (mr *MockRegistryServiceMockRecorder) DeleteServerVersion(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServerVersion", reflect.TypeOf((*MockRegistryService)(nil).DeleteServerVersion), varargs...)
}

// DeleteSkillVersion mocks base method.
func (m *MockRegistryService) DeleteSkillVersion(ctx context.Context, opts ...service.Option) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSkillVersion", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSkillVersion indicates an expected call of DeleteSkillVersion.
func (mr *MockRegistryServiceMockRecorder) DeleteSkillVersion(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSkillVersion", reflect.TypeOf((*MockRegistryService)(nil).DeleteSkillVersion), varargs...)
}

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

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

// GetRegistryByName mocks base method.
func (m *MockRegistryService) GetRegistryByName(ctx context.Context, name string) (*service.RegistryInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegistryByName", ctx, name)
	ret0, _ := ret[0].(*service.RegistryInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetServerVersion mocks base method.
func (m *MockRegistryService) GetServerVersion(ctx context.Context, opts ...service.Option) (*v0.ServerJSON, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetServerVersion", varargs...)
	ret0, _ := ret[0].(*v0.ServerJSON)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServerVersion indicates an expected call of GetServerVersion.
func (mr *MockRegistryServiceMockRecorder) GetServerVersion(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerVersion", reflect.TypeOf((*MockRegistryService)(nil).GetServerVersion), varargs...)
}

// GetSkillVersion mocks base method.
func (m *MockRegistryService) GetSkillVersion(ctx context.Context, opts ...service.Option) (*service.Skill, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSkillVersion", varargs...)
	ret0, _ := ret[0].(*service.Skill)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSkillVersion indicates an expected call of GetSkillVersion.
func (mr *MockRegistryServiceMockRecorder) GetSkillVersion(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSkillVersion", reflect.TypeOf((*MockRegistryService)(nil).GetSkillVersion), varargs...)
}

// GetSourceByName mocks base method.
func (m *MockRegistryService) GetSourceByName(ctx context.Context, name string) (*service.SourceInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSourceByName", ctx, name)
	ret0, _ := ret[0].(*service.SourceInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRegistries mocks base method.
func (m *MockRegistryService) ListRegistries(ctx context.Context) ([]service.RegistryInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRegistries", ctx)
	ret0, _ := ret[0].([]service.RegistryInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRegistryEntries mocks base method.
func (m *MockRegistryService) ListRegistryEntries(ctx context.Context, registryName string) ([]service.RegistryEntryInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRegistryEntries", ctx, registryName)
	ret0, _ := ret[0].([]service.RegistryEntryInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListServerVersions mocks base method.
func (m *MockRegistryService) ListServerVersions(ctx context.Context, opts ...service.Option) ([]*v0.ServerJSON, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListServerVersions", varargs...)
	ret0, _ := ret[0].([]*v0.ServerJSON)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServerVersions indicates an expected call of ListServerVersions.
func (mr *MockRegistryServiceMockRecorder) ListServerVersions(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerVersions", reflect.TypeOf((*MockRegistryService)(nil).ListServerVersions), varargs...)
}

// ListServers mocks base method.
func (m *MockRegistryService) ListServers(ctx context.Context, opts ...service.Option) (*service.ListServersResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListServers", varargs...)
	ret0, _ := ret[0].(*service.ListServersResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServers indicates an expected call of ListServers.
func (mr *MockRegistryServiceMockRecorder) ListServers(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServers", reflect.TypeOf((*MockRegistryService)(nil).ListServers), varargs...)
}

// ListSkills mocks base method.
func (m *MockRegistryService) ListSkills(ctx context.Context, opts ...service.Option) (*service.ListSkillsResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSkills", varargs...)
	ret0, _ := ret[0].(*service.ListSkillsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSkills indicates an expected call of ListSkills.
func (mr *MockRegistryServiceMockRecorder) ListSkills(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSkills", reflect.TypeOf((*MockRegistryService)(nil).ListSkills), varargs...)
}

// ListSourceEntries mocks base method.
func (m *MockRegistryService) ListSourceEntries(ctx context.Context, sourceName string) ([]service.SourceEntryInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSourceEntries", ctx, sourceName)
	ret0, _ := ret[0].([]service.SourceEntryInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSources mocks base method.
func (m *MockRegistryService) ListSources(ctx context.Context) ([]service.SourceInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSources", ctx)
	ret0, _ := ret[0].([]service.SourceInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// ProcessInlineSourceData indicates an expected call of ProcessInlineSourceData.
func (mr *MockRegistryServiceMockRecorder) ProcessInlineSourceData(ctx, name, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessInlineSourceData", reflect.TypeOf((*MockRegistryService)(nil).ProcessInlineSourceData), ctx, name, data)
}

// PublishServerVersion mocks base method.
func (m *MockRegistryService) PublishServerVersion(ctx context.Context, opts ...service.Option) (*v0.ServerJSON, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PublishServerVersion", varargs...)
	ret0, _ := ret[0].(*v0.ServerJSON)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PublishServerVersion indicates an expected call of PublishServerVersion.
func (mr *MockRegistryServiceMockRecorder) PublishServerVersion(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishServerVersion", reflect.TypeOf((*MockRegistryService)(nil).PublishServerVersion), varargs...)
}

// PublishSkill mocks base method.
func (m *MockRegistryService) PublishSkill(ctx context.Context, skill *service.Skill, opts ...service.Option) (*service.Skill, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, skill}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PublishSkill", varargs...)
	ret0, _ := ret[0].(*service.Skill)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PublishSkill indicates an expected call of PublishSkill.
func (mr *MockRegistryServiceMockRecorder) PublishSkill(ctx, skill any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, skill}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishSkill", reflect.TypeOf((*MockRegistryService)(nil).PublishSkill), varargs...)
}

// UpdateEntryClaims mocks base method.
func (m *MockRegistryService) UpdateEntryClaims(ctx context.Context, opts ...service.Option) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateEntryClaims", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateEntryClaims indicates an expected call of UpdateEntryClaims.
func (mr *MockRegistryServiceMockRecorder) UpdateEntryClaims(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEntryClaims", reflect.TypeOf((*MockRegistryService)(nil).UpdateEntryClaims), varargs...)
}

// UpdateRegistry mocks base method.
func (m *MockRegistryService) UpdateRegistry(ctx context.Context, name string, req *service.RegistryCreateRequest) (*service.RegistryInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRegistry", ctx, name, req)
	ret0, _ := ret[0].(*service.RegistryInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateSource mocks base method.
func (m *MockRegistryService) UpdateSource(ctx context.Context, name string, req *service.SourceCreateRequest) (*service.SourceInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSource", ctx, name, req)
	ret0, _ := ret[0].(*service.SourceInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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