cipd/api/cipd/v1/repo_grpc.mock.pb.go

// Code generated by MockGen. DO NOT EDIT.
// Source: repo_grpc.pb.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockRepositoryClient is a mock of RepositoryClient interface.
type MockRepositoryClient struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryClientMockRecorder
}

// MockRepositoryClientMockRecorder is the mock recorder for MockRepositoryClient.
type MockRepositoryClientMockRecorder struct {
	mock *MockRepositoryClient
}

// NewMockRepositoryClient creates a new mock instance.
func NewMockRepositoryClient(ctrl *gomock.Controller) *MockRepositoryClient {
	mock := &MockRepositoryClient{ctrl: ctrl}
	mock.recorder = &MockRepositoryClientMockRecorder{mock}
	return mock
}

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

// AttachMetadata mocks base method.
func (m *MockRepositoryClient) AttachMetadata(ctx context.Context, in *AttachMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AttachMetadata", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachMetadata indicates an expected call of AttachMetadata.
func (mr *MockRepositoryClientMockRecorder) AttachMetadata(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachMetadata", reflect.TypeOf((*MockRepositoryClient)(nil).AttachMetadata), varargs...)
}

// AttachTags mocks base method.
func (m *MockRepositoryClient) AttachTags(ctx context.Context, in *AttachTagsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AttachTags", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachTags indicates an expected call of AttachTags.
func (mr *MockRepositoryClientMockRecorder) AttachTags(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachTags", reflect.TypeOf((*MockRepositoryClient)(nil).AttachTags), varargs...)
}

// CreateRef mocks base method.
func (m *MockRepositoryClient) CreateRef(ctx context.Context, in *Ref, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateRef", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRef indicates an expected call of CreateRef.
func (mr *MockRepositoryClientMockRecorder) CreateRef(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRef", reflect.TypeOf((*MockRepositoryClient)(nil).CreateRef), varargs...)
}

// DeletePackage mocks base method.
func (m *MockRepositoryClient) DeletePackage(ctx context.Context, in *PackageRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePackage", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePackage indicates an expected call of DeletePackage.
func (mr *MockRepositoryClientMockRecorder) DeletePackage(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePackage", reflect.TypeOf((*MockRepositoryClient)(nil).DeletePackage), varargs...)
}

// DeleteRef mocks base method.
func (m *MockRepositoryClient) DeleteRef(ctx context.Context, in *DeleteRefRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteRef", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRef indicates an expected call of DeleteRef.
func (mr *MockRepositoryClientMockRecorder) DeleteRef(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRef", reflect.TypeOf((*MockRepositoryClient)(nil).DeleteRef), varargs...)
}

// DescribeBootstrapBundle mocks base method.
func (m *MockRepositoryClient) DescribeBootstrapBundle(ctx context.Context, in *DescribeBootstrapBundleRequest, opts ...grpc.CallOption) (*DescribeBootstrapBundleResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBootstrapBundle", varargs...)
	ret0, _ := ret[0].(*DescribeBootstrapBundleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBootstrapBundle indicates an expected call of DescribeBootstrapBundle.
func (mr *MockRepositoryClientMockRecorder) DescribeBootstrapBundle(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBootstrapBundle", reflect.TypeOf((*MockRepositoryClient)(nil).DescribeBootstrapBundle), varargs...)
}

// DescribeClient mocks base method.
func (m *MockRepositoryClient) DescribeClient(ctx context.Context, in *DescribeClientRequest, opts ...grpc.CallOption) (*DescribeClientResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClient", varargs...)
	ret0, _ := ret[0].(*DescribeClientResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClient indicates an expected call of DescribeClient.
func (mr *MockRepositoryClientMockRecorder) DescribeClient(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClient", reflect.TypeOf((*MockRepositoryClient)(nil).DescribeClient), varargs...)
}

// DescribeInstance mocks base method.
func (m *MockRepositoryClient) DescribeInstance(ctx context.Context, in *DescribeInstanceRequest, opts ...grpc.CallOption) (*DescribeInstanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeInstance", varargs...)
	ret0, _ := ret[0].(*DescribeInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstance indicates an expected call of DescribeInstance.
func (mr *MockRepositoryClientMockRecorder) DescribeInstance(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstance", reflect.TypeOf((*MockRepositoryClient)(nil).DescribeInstance), varargs...)
}

// DetachMetadata mocks base method.
func (m *MockRepositoryClient) DetachMetadata(ctx context.Context, in *DetachMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DetachMetadata", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachMetadata indicates an expected call of DetachMetadata.
func (mr *MockRepositoryClientMockRecorder) DetachMetadata(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachMetadata", reflect.TypeOf((*MockRepositoryClient)(nil).DetachMetadata), varargs...)
}

// DetachTags mocks base method.
func (m *MockRepositoryClient) DetachTags(ctx context.Context, in *DetachTagsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DetachTags", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachTags indicates an expected call of DetachTags.
func (mr *MockRepositoryClientMockRecorder) DetachTags(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachTags", reflect.TypeOf((*MockRepositoryClient)(nil).DetachTags), varargs...)
}

// GetInheritedPrefixMetadata mocks base method.
func (m *MockRepositoryClient) GetInheritedPrefixMetadata(ctx context.Context, in *PrefixRequest, opts ...grpc.CallOption) (*InheritedPrefixMetadata, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInheritedPrefixMetadata", varargs...)
	ret0, _ := ret[0].(*InheritedPrefixMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInheritedPrefixMetadata indicates an expected call of GetInheritedPrefixMetadata.
func (mr *MockRepositoryClientMockRecorder) GetInheritedPrefixMetadata(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInheritedPrefixMetadata", reflect.TypeOf((*MockRepositoryClient)(nil).GetInheritedPrefixMetadata), varargs...)
}

// GetInstanceURL mocks base method.
func (m *MockRepositoryClient) GetInstanceURL(ctx context.Context, in *GetInstanceURLRequest, opts ...grpc.CallOption) (*ObjectURL, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInstanceURL", varargs...)
	ret0, _ := ret[0].(*ObjectURL)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceURL indicates an expected call of GetInstanceURL.
func (mr *MockRepositoryClientMockRecorder) GetInstanceURL(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceURL", reflect.TypeOf((*MockRepositoryClient)(nil).GetInstanceURL), varargs...)
}

// GetPrefixMetadata mocks base method.
func (m *MockRepositoryClient) GetPrefixMetadata(ctx context.Context, in *PrefixRequest, opts ...grpc.CallOption) (*PrefixMetadata, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPrefixMetadata", varargs...)
	ret0, _ := ret[0].(*PrefixMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrefixMetadata indicates an expected call of GetPrefixMetadata.
func (mr *MockRepositoryClientMockRecorder) GetPrefixMetadata(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrefixMetadata", reflect.TypeOf((*MockRepositoryClient)(nil).GetPrefixMetadata), varargs...)
}

// GetRolesInPrefix mocks base method.
func (m *MockRepositoryClient) GetRolesInPrefix(ctx context.Context, in *PrefixRequest, opts ...grpc.CallOption) (*RolesInPrefixResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRolesInPrefix", varargs...)
	ret0, _ := ret[0].(*RolesInPrefixResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRolesInPrefix indicates an expected call of GetRolesInPrefix.
func (mr *MockRepositoryClientMockRecorder) GetRolesInPrefix(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolesInPrefix", reflect.TypeOf((*MockRepositoryClient)(nil).GetRolesInPrefix), varargs...)
}

// GetRolesInPrefixOnBehalfOf mocks base method.
func (m *MockRepositoryClient) GetRolesInPrefixOnBehalfOf(ctx context.Context, in *PrefixRequestOnBehalfOf, opts ...grpc.CallOption) (*RolesInPrefixResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRolesInPrefixOnBehalfOf", varargs...)
	ret0, _ := ret[0].(*RolesInPrefixResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRolesInPrefixOnBehalfOf indicates an expected call of GetRolesInPrefixOnBehalfOf.
func (mr *MockRepositoryClientMockRecorder) GetRolesInPrefixOnBehalfOf(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolesInPrefixOnBehalfOf", reflect.TypeOf((*MockRepositoryClient)(nil).GetRolesInPrefixOnBehalfOf), varargs...)
}

// HidePackage mocks base method.
func (m *MockRepositoryClient) HidePackage(ctx context.Context, in *PackageRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HidePackage", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HidePackage indicates an expected call of HidePackage.
func (mr *MockRepositoryClientMockRecorder) HidePackage(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HidePackage", reflect.TypeOf((*MockRepositoryClient)(nil).HidePackage), varargs...)
}

// ListInstances mocks base method.
func (m *MockRepositoryClient) ListInstances(ctx context.Context, in *ListInstancesRequest, opts ...grpc.CallOption) (*ListInstancesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListInstances", varargs...)
	ret0, _ := ret[0].(*ListInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInstances indicates an expected call of ListInstances.
func (mr *MockRepositoryClientMockRecorder) ListInstances(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstances", reflect.TypeOf((*MockRepositoryClient)(nil).ListInstances), varargs...)
}

// ListMetadata mocks base method.
func (m *MockRepositoryClient) ListMetadata(ctx context.Context, in *ListMetadataRequest, opts ...grpc.CallOption) (*ListMetadataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMetadata", varargs...)
	ret0, _ := ret[0].(*ListMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMetadata indicates an expected call of ListMetadata.
func (mr *MockRepositoryClientMockRecorder) ListMetadata(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMetadata", reflect.TypeOf((*MockRepositoryClient)(nil).ListMetadata), varargs...)
}

// ListPrefix mocks base method.
func (m *MockRepositoryClient) ListPrefix(ctx context.Context, in *ListPrefixRequest, opts ...grpc.CallOption) (*ListPrefixResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPrefix", varargs...)
	ret0, _ := ret[0].(*ListPrefixResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPrefix indicates an expected call of ListPrefix.
func (mr *MockRepositoryClientMockRecorder) ListPrefix(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPrefix", reflect.TypeOf((*MockRepositoryClient)(nil).ListPrefix), varargs...)
}

// ListRefs mocks base method.
func (m *MockRepositoryClient) ListRefs(ctx context.Context, in *ListRefsRequest, opts ...grpc.CallOption) (*ListRefsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRefs", varargs...)
	ret0, _ := ret[0].(*ListRefsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRefs indicates an expected call of ListRefs.
func (mr *MockRepositoryClientMockRecorder) ListRefs(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRefs", reflect.TypeOf((*MockRepositoryClient)(nil).ListRefs), varargs...)
}

// RegisterInstance mocks base method.
func (m *MockRepositoryClient) RegisterInstance(ctx context.Context, in *Instance, opts ...grpc.CallOption) (*RegisterInstanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterInstance", varargs...)
	ret0, _ := ret[0].(*RegisterInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterInstance indicates an expected call of RegisterInstance.
func (mr *MockRepositoryClientMockRecorder) RegisterInstance(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstance", reflect.TypeOf((*MockRepositoryClient)(nil).RegisterInstance), varargs...)
}

// ResolveVersion mocks base method.
func (m *MockRepositoryClient) ResolveVersion(ctx context.Context, in *ResolveVersionRequest, opts ...grpc.CallOption) (*Instance, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResolveVersion", varargs...)
	ret0, _ := ret[0].(*Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveVersion indicates an expected call of ResolveVersion.
func (mr *MockRepositoryClientMockRecorder) ResolveVersion(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveVersion", reflect.TypeOf((*MockRepositoryClient)(nil).ResolveVersion), varargs...)
}

// SearchInstances mocks base method.
func (m *MockRepositoryClient) SearchInstances(ctx context.Context, in *SearchInstancesRequest, opts ...grpc.CallOption) (*SearchInstancesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchInstances", varargs...)
	ret0, _ := ret[0].(*SearchInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchInstances indicates an expected call of SearchInstances.
func (mr *MockRepositoryClientMockRecorder) SearchInstances(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchInstances", reflect.TypeOf((*MockRepositoryClient)(nil).SearchInstances), varargs...)
}

// UnhidePackage mocks base method.
func (m *MockRepositoryClient) UnhidePackage(ctx context.Context, in *PackageRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnhidePackage", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnhidePackage indicates an expected call of UnhidePackage.
func (mr *MockRepositoryClientMockRecorder) UnhidePackage(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnhidePackage", reflect.TypeOf((*MockRepositoryClient)(nil).UnhidePackage), varargs...)
}

// UpdatePrefixMetadata mocks base method.
func (m *MockRepositoryClient) UpdatePrefixMetadata(ctx context.Context, in *PrefixMetadata, opts ...grpc.CallOption) (*PrefixMetadata, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePrefixMetadata", varargs...)
	ret0, _ := ret[0].(*PrefixMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePrefixMetadata indicates an expected call of UpdatePrefixMetadata.
func (mr *MockRepositoryClientMockRecorder) UpdatePrefixMetadata(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePrefixMetadata", reflect.TypeOf((*MockRepositoryClient)(nil).UpdatePrefixMetadata), varargs...)
}

// MockRepositoryServer is a mock of RepositoryServer interface.
type MockRepositoryServer struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoryServerMockRecorder
}

// MockRepositoryServerMockRecorder is the mock recorder for MockRepositoryServer.
type MockRepositoryServerMockRecorder struct {
	mock *MockRepositoryServer
}

// NewMockRepositoryServer creates a new mock instance.
func NewMockRepositoryServer(ctrl *gomock.Controller) *MockRepositoryServer {
	mock := &MockRepositoryServer{ctrl: ctrl}
	mock.recorder = &MockRepositoryServerMockRecorder{mock}
	return mock
}

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

// AttachMetadata mocks base method.
func (m *MockRepositoryServer) AttachMetadata(arg0 context.Context, arg1 *AttachMetadataRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachMetadata", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachMetadata indicates an expected call of AttachMetadata.
func (mr *MockRepositoryServerMockRecorder) AttachMetadata(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachMetadata", reflect.TypeOf((*MockRepositoryServer)(nil).AttachMetadata), arg0, arg1)
}

// AttachTags mocks base method.
func (m *MockRepositoryServer) AttachTags(arg0 context.Context, arg1 *AttachTagsRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachTags", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachTags indicates an expected call of AttachTags.
func (mr *MockRepositoryServerMockRecorder) AttachTags(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachTags", reflect.TypeOf((*MockRepositoryServer)(nil).AttachTags), arg0, arg1)
}

// CreateRef mocks base method.
func (m *MockRepositoryServer) CreateRef(arg0 context.Context, arg1 *Ref) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRef", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRef indicates an expected call of CreateRef.
func (mr *MockRepositoryServerMockRecorder) CreateRef(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRef", reflect.TypeOf((*MockRepositoryServer)(nil).CreateRef), arg0, arg1)
}

// DeletePackage mocks base method.
func (m *MockRepositoryServer) DeletePackage(arg0 context.Context, arg1 *PackageRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePackage", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePackage indicates an expected call of DeletePackage.
func (mr *MockRepositoryServerMockRecorder) DeletePackage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePackage", reflect.TypeOf((*MockRepositoryServer)(nil).DeletePackage), arg0, arg1)
}

// DeleteRef mocks base method.
func (m *MockRepositoryServer) DeleteRef(arg0 context.Context, arg1 *DeleteRefRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRef", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRef indicates an expected call of DeleteRef.
func (mr *MockRepositoryServerMockRecorder) DeleteRef(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRef", reflect.TypeOf((*MockRepositoryServer)(nil).DeleteRef), arg0, arg1)
}

// DescribeBootstrapBundle mocks base method.
func (m *MockRepositoryServer) DescribeBootstrapBundle(arg0 context.Context, arg1 *DescribeBootstrapBundleRequest) (*DescribeBootstrapBundleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBootstrapBundle", arg0, arg1)
	ret0, _ := ret[0].(*DescribeBootstrapBundleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBootstrapBundle indicates an expected call of DescribeBootstrapBundle.
func (mr *MockRepositoryServerMockRecorder) DescribeBootstrapBundle(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBootstrapBundle", reflect.TypeOf((*MockRepositoryServer)(nil).DescribeBootstrapBundle), arg0, arg1)
}

// DescribeClient mocks base method.
func (m *MockRepositoryServer) DescribeClient(arg0 context.Context, arg1 *DescribeClientRequest) (*DescribeClientResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClient", arg0, arg1)
	ret0, _ := ret[0].(*DescribeClientResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClient indicates an expected call of DescribeClient.
func (mr *MockRepositoryServerMockRecorder) DescribeClient(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClient", reflect.TypeOf((*MockRepositoryServer)(nil).DescribeClient), arg0, arg1)
}

// DescribeInstance mocks base method.
func (m *MockRepositoryServer) DescribeInstance(arg0 context.Context, arg1 *DescribeInstanceRequest) (*DescribeInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstance", arg0, arg1)
	ret0, _ := ret[0].(*DescribeInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstance indicates an expected call of DescribeInstance.
func (mr *MockRepositoryServerMockRecorder) DescribeInstance(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstance", reflect.TypeOf((*MockRepositoryServer)(nil).DescribeInstance), arg0, arg1)
}

// DetachMetadata mocks base method.
func (m *MockRepositoryServer) DetachMetadata(arg0 context.Context, arg1 *DetachMetadataRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachMetadata", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachMetadata indicates an expected call of DetachMetadata.
func (mr *MockRepositoryServerMockRecorder) DetachMetadata(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachMetadata", reflect.TypeOf((*MockRepositoryServer)(nil).DetachMetadata), arg0, arg1)
}

// DetachTags mocks base method.
func (m *MockRepositoryServer) DetachTags(arg0 context.Context, arg1 *DetachTagsRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachTags", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachTags indicates an expected call of DetachTags.
func (mr *MockRepositoryServerMockRecorder) DetachTags(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachTags", reflect.TypeOf((*MockRepositoryServer)(nil).DetachTags), arg0, arg1)
}

// GetInheritedPrefixMetadata mocks base method.
func (m *MockRepositoryServer) GetInheritedPrefixMetadata(arg0 context.Context, arg1 *PrefixRequest) (*InheritedPrefixMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInheritedPrefixMetadata", arg0, arg1)
	ret0, _ := ret[0].(*InheritedPrefixMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInheritedPrefixMetadata indicates an expected call of GetInheritedPrefixMetadata.
func (mr *MockRepositoryServerMockRecorder) GetInheritedPrefixMetadata(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInheritedPrefixMetadata", reflect.TypeOf((*MockRepositoryServer)(nil).GetInheritedPrefixMetadata), arg0, arg1)
}

// GetInstanceURL mocks base method.
func (m *MockRepositoryServer) GetInstanceURL(arg0 context.Context, arg1 *GetInstanceURLRequest) (*ObjectURL, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceURL", arg0, arg1)
	ret0, _ := ret[0].(*ObjectURL)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceURL indicates an expected call of GetInstanceURL.
func (mr *MockRepositoryServerMockRecorder) GetInstanceURL(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceURL", reflect.TypeOf((*MockRepositoryServer)(nil).GetInstanceURL), arg0, arg1)
}

// GetPrefixMetadata mocks base method.
func (m *MockRepositoryServer) GetPrefixMetadata(arg0 context.Context, arg1 *PrefixRequest) (*PrefixMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPrefixMetadata", arg0, arg1)
	ret0, _ := ret[0].(*PrefixMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrefixMetadata indicates an expected call of GetPrefixMetadata.
func (mr *MockRepositoryServerMockRecorder) GetPrefixMetadata(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrefixMetadata", reflect.TypeOf((*MockRepositoryServer)(nil).GetPrefixMetadata), arg0, arg1)
}

// GetRolesInPrefix mocks base method.
func (m *MockRepositoryServer) GetRolesInPrefix(arg0 context.Context, arg1 *PrefixRequest) (*RolesInPrefixResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRolesInPrefix", arg0, arg1)
	ret0, _ := ret[0].(*RolesInPrefixResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRolesInPrefix indicates an expected call of GetRolesInPrefix.
func (mr *MockRepositoryServerMockRecorder) GetRolesInPrefix(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolesInPrefix", reflect.TypeOf((*MockRepositoryServer)(nil).GetRolesInPrefix), arg0, arg1)
}

// GetRolesInPrefixOnBehalfOf mocks base method.
func (m *MockRepositoryServer) GetRolesInPrefixOnBehalfOf(arg0 context.Context, arg1 *PrefixRequestOnBehalfOf) (*RolesInPrefixResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRolesInPrefixOnBehalfOf", arg0, arg1)
	ret0, _ := ret[0].(*RolesInPrefixResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRolesInPrefixOnBehalfOf indicates an expected call of GetRolesInPrefixOnBehalfOf.
func (mr *MockRepositoryServerMockRecorder) GetRolesInPrefixOnBehalfOf(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolesInPrefixOnBehalfOf", reflect.TypeOf((*MockRepositoryServer)(nil).GetRolesInPrefixOnBehalfOf), arg0, arg1)
}

// HidePackage mocks base method.
func (m *MockRepositoryServer) HidePackage(arg0 context.Context, arg1 *PackageRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HidePackage", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HidePackage indicates an expected call of HidePackage.
func (mr *MockRepositoryServerMockRecorder) HidePackage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HidePackage", reflect.TypeOf((*MockRepositoryServer)(nil).HidePackage), arg0, arg1)
}

// ListInstances mocks base method.
func (m *MockRepositoryServer) ListInstances(arg0 context.Context, arg1 *ListInstancesRequest) (*ListInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInstances", arg0, arg1)
	ret0, _ := ret[0].(*ListInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInstances indicates an expected call of ListInstances.
func (mr *MockRepositoryServerMockRecorder) ListInstances(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstances", reflect.TypeOf((*MockRepositoryServer)(nil).ListInstances), arg0, arg1)
}

// ListMetadata mocks base method.
func (m *MockRepositoryServer) ListMetadata(arg0 context.Context, arg1 *ListMetadataRequest) (*ListMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMetadata", arg0, arg1)
	ret0, _ := ret[0].(*ListMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMetadata indicates an expected call of ListMetadata.
func (mr *MockRepositoryServerMockRecorder) ListMetadata(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMetadata", reflect.TypeOf((*MockRepositoryServer)(nil).ListMetadata), arg0, arg1)
}

// ListPrefix mocks base method.
func (m *MockRepositoryServer) ListPrefix(arg0 context.Context, arg1 *ListPrefixRequest) (*ListPrefixResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPrefix", arg0, arg1)
	ret0, _ := ret[0].(*ListPrefixResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPrefix indicates an expected call of ListPrefix.
func (mr *MockRepositoryServerMockRecorder) ListPrefix(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPrefix", reflect.TypeOf((*MockRepositoryServer)(nil).ListPrefix), arg0, arg1)
}

// ListRefs mocks base method.
func (m *MockRepositoryServer) ListRefs(arg0 context.Context, arg1 *ListRefsRequest) (*ListRefsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRefs", arg0, arg1)
	ret0, _ := ret[0].(*ListRefsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRefs indicates an expected call of ListRefs.
func (mr *MockRepositoryServerMockRecorder) ListRefs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRefs", reflect.TypeOf((*MockRepositoryServer)(nil).ListRefs), arg0, arg1)
}

// RegisterInstance mocks base method.
func (m *MockRepositoryServer) RegisterInstance(arg0 context.Context, arg1 *Instance) (*RegisterInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterInstance", arg0, arg1)
	ret0, _ := ret[0].(*RegisterInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterInstance indicates an expected call of RegisterInstance.
func (mr *MockRepositoryServerMockRecorder) RegisterInstance(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstance", reflect.TypeOf((*MockRepositoryServer)(nil).RegisterInstance), arg0, arg1)
}

// ResolveVersion mocks base method.
func (m *MockRepositoryServer) ResolveVersion(arg0 context.Context, arg1 *ResolveVersionRequest) (*Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveVersion", arg0, arg1)
	ret0, _ := ret[0].(*Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveVersion indicates an expected call of ResolveVersion.
func (mr *MockRepositoryServerMockRecorder) ResolveVersion(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveVersion", reflect.TypeOf((*MockRepositoryServer)(nil).ResolveVersion), arg0, arg1)
}

// SearchInstances mocks base method.
func (m *MockRepositoryServer) SearchInstances(arg0 context.Context, arg1 *SearchInstancesRequest) (*SearchInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchInstances", arg0, arg1)
	ret0, _ := ret[0].(*SearchInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchInstances indicates an expected call of SearchInstances.
func (mr *MockRepositoryServerMockRecorder) SearchInstances(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchInstances", reflect.TypeOf((*MockRepositoryServer)(nil).SearchInstances), arg0, arg1)
}

// UnhidePackage mocks base method.
func (m *MockRepositoryServer) UnhidePackage(arg0 context.Context, arg1 *PackageRequest) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnhidePackage", arg0, arg1)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnhidePackage indicates an expected call of UnhidePackage.
func (mr *MockRepositoryServerMockRecorder) UnhidePackage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnhidePackage", reflect.TypeOf((*MockRepositoryServer)(nil).UnhidePackage), arg0, arg1)
}

// UpdatePrefixMetadata mocks base method.
func (m *MockRepositoryServer) UpdatePrefixMetadata(arg0 context.Context, arg1 *PrefixMetadata) (*PrefixMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePrefixMetadata", arg0, arg1)
	ret0, _ := ret[0].(*PrefixMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePrefixMetadata indicates an expected call of UpdatePrefixMetadata.
func (mr *MockRepositoryServerMockRecorder) UpdatePrefixMetadata(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePrefixMetadata", reflect.TypeOf((*MockRepositoryServer)(nil).UpdatePrefixMetadata), arg0, arg1)
}

// mustEmbedUnimplementedRepositoryServer mocks base method.
func (m *MockRepositoryServer) mustEmbedUnimplementedRepositoryServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedRepositoryServer")
}

// mustEmbedUnimplementedRepositoryServer indicates an expected call of mustEmbedUnimplementedRepositoryServer.
func (mr *MockRepositoryServerMockRecorder) mustEmbedUnimplementedRepositoryServer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedRepositoryServer", reflect.TypeOf((*MockRepositoryServer)(nil).mustEmbedUnimplementedRepositoryServer))
}

// MockUnsafeRepositoryServer is a mock of UnsafeRepositoryServer interface.
type MockUnsafeRepositoryServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeRepositoryServerMockRecorder
}

// MockUnsafeRepositoryServerMockRecorder is the mock recorder for MockUnsafeRepositoryServer.
type MockUnsafeRepositoryServerMockRecorder struct {
	mock *MockUnsafeRepositoryServer
}

// NewMockUnsafeRepositoryServer creates a new mock instance.
func NewMockUnsafeRepositoryServer(ctrl *gomock.Controller) *MockUnsafeRepositoryServer {
	mock := &MockUnsafeRepositoryServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeRepositoryServerMockRecorder{mock}
	return mock
}

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

// mustEmbedUnimplementedRepositoryServer mocks base method.
func (m *MockUnsafeRepositoryServer) mustEmbedUnimplementedRepositoryServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedRepositoryServer")
}

// mustEmbedUnimplementedRepositoryServer indicates an expected call of mustEmbedUnimplementedRepositoryServer.
func (mr *MockUnsafeRepositoryServerMockRecorder) mustEmbedUnimplementedRepositoryServer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedRepositoryServer", reflect.TypeOf((*MockUnsafeRepositoryServer)(nil).mustEmbedUnimplementedRepositoryServer))
}