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

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

import (
	context "context"
	reflect "reflect"

	common "d7y.io/api/v2/pkg/apis/common/v2"
	scheduler "d7y.io/api/v2/pkg/apis/scheduler/v2"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockSchedulerClient is a mock of SchedulerClient interface.
type MockSchedulerClient struct {
	ctrl     *gomock.Controller
	recorder *MockSchedulerClientMockRecorder
	isgomock struct{}
}

// MockSchedulerClientMockRecorder is the mock recorder for MockSchedulerClient.
type MockSchedulerClientMockRecorder struct {
	mock *MockSchedulerClient
}

// NewMockSchedulerClient creates a new mock instance.
func NewMockSchedulerClient(ctrl *gomock.Controller) *MockSchedulerClient {
	mock := &MockSchedulerClient{ctrl: ctrl}
	mock.recorder = &MockSchedulerClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// StatCachePeer mocks base method.
func (m *MockSchedulerClient) StatCachePeer(ctx context.Context, in *scheduler.StatCachePeerRequest, opts ...grpc.CallOption) (*common.CachePeer, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatCachePeer", varargs...)
	ret0, _ := ret[0].(*common.CachePeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StatCacheTask mocks base method.
func (m *MockSchedulerClient) StatCacheTask(ctx context.Context, in *scheduler.StatCacheTaskRequest, opts ...grpc.CallOption) (*common.CacheTask, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatCacheTask", varargs...)
	ret0, _ := ret[0].(*common.CacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// StatPeer mocks base method.
func (m *MockSchedulerClient) StatPeer(ctx context.Context, in *scheduler.StatPeerRequest, opts ...grpc.CallOption) (*common.Peer, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatPeer", varargs...)
	ret0, _ := ret[0].(*common.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StatPersistentCachePeer mocks base method.
func (m *MockSchedulerClient) StatPersistentCachePeer(ctx context.Context, in *scheduler.StatPersistentCachePeerRequest, opts ...grpc.CallOption) (*common.PersistentCachePeer, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatPersistentCachePeer", varargs...)
	ret0, _ := ret[0].(*common.PersistentCachePeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StatPersistentCacheTask mocks base method.
func (m *MockSchedulerClient) StatPersistentCacheTask(ctx context.Context, in *scheduler.StatPersistentCacheTaskRequest, opts ...grpc.CallOption) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatPersistentCacheTask", varargs...)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StatPersistentPeer mocks base method.
func (m *MockSchedulerClient) StatPersistentPeer(ctx context.Context, in *scheduler.StatPersistentPeerRequest, opts ...grpc.CallOption) (*common.PersistentPeer, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatPersistentPeer", varargs...)
	ret0, _ := ret[0].(*common.PersistentPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StatPersistentTask mocks base method.
func (m *MockSchedulerClient) StatPersistentTask(ctx context.Context, in *scheduler.StatPersistentTaskRequest, opts ...grpc.CallOption) (*common.PersistentTask, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatPersistentTask", varargs...)
	ret0, _ := ret[0].(*common.PersistentTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StatTask mocks base method.
func (m *MockSchedulerClient) StatTask(ctx context.Context, in *scheduler.StatTaskRequest, opts ...grpc.CallOption) (*common.Task, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StatTask", varargs...)
	ret0, _ := ret[0].(*common.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UploadPersistentCacheTaskFinished mocks base method.
func (m *MockSchedulerClient) UploadPersistentCacheTaskFinished(ctx context.Context, in *scheduler.UploadPersistentCacheTaskFinishedRequest, opts ...grpc.CallOption) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadPersistentCacheTaskFinished", varargs...)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// UploadPersistentTaskFinished mocks base method.
func (m *MockSchedulerClient) UploadPersistentTaskFinished(ctx context.Context, in *scheduler.UploadPersistentTaskFinishedRequest, opts ...grpc.CallOption) (*common.PersistentTask, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadPersistentTaskFinished", varargs...)
	ret0, _ := ret[0].(*common.PersistentTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockScheduler_AnnouncePeerClient is a mock of Scheduler_AnnouncePeerClient interface.
type MockScheduler_AnnouncePeerClient struct {
	ctrl     *gomock.Controller
	recorder *MockScheduler_AnnouncePeerClientMockRecorder
	isgomock struct{}
}

// MockScheduler_AnnouncePeerClientMockRecorder is the mock recorder for MockScheduler_AnnouncePeerClient.
type MockScheduler_AnnouncePeerClientMockRecorder struct {
	mock *MockScheduler_AnnouncePeerClient
}

// NewMockScheduler_AnnouncePeerClient creates a new mock instance.
func NewMockScheduler_AnnouncePeerClient(ctrl *gomock.Controller) *MockScheduler_AnnouncePeerClient {
	mock := &MockScheduler_AnnouncePeerClient{ctrl: ctrl}
	mock.recorder = &MockScheduler_AnnouncePeerClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockScheduler_AnnouncePeerClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockScheduler_AnnouncePeerClient) Recv() (*scheduler.AnnouncePeerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*scheduler.AnnouncePeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePeerClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_AnnouncePeerClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockScheduler_AnnouncePeerClient) Send(arg0 *scheduler.AnnouncePeerRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockScheduler_AnnouncePeerClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePeerClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_AnnouncePeerClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePeerClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockScheduler_AnnouncePeerClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

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

// MockScheduler_AnnounceCachePeerClient is a mock of Scheduler_AnnounceCachePeerClient interface.
type MockScheduler_AnnounceCachePeerClient struct {
	ctrl     *gomock.Controller
	recorder *MockScheduler_AnnounceCachePeerClientMockRecorder
	isgomock struct{}
}

// MockScheduler_AnnounceCachePeerClientMockRecorder is the mock recorder for MockScheduler_AnnounceCachePeerClient.
type MockScheduler_AnnounceCachePeerClientMockRecorder struct {
	mock *MockScheduler_AnnounceCachePeerClient
}

// NewMockScheduler_AnnounceCachePeerClient creates a new mock instance.
func NewMockScheduler_AnnounceCachePeerClient(ctrl *gomock.Controller) *MockScheduler_AnnounceCachePeerClient {
	mock := &MockScheduler_AnnounceCachePeerClient{ctrl: ctrl}
	mock.recorder = &MockScheduler_AnnounceCachePeerClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockScheduler_AnnounceCachePeerClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockScheduler_AnnounceCachePeerClient) Recv() (*scheduler.AnnounceCachePeerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*scheduler.AnnounceCachePeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockScheduler_AnnounceCachePeerClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_AnnounceCachePeerClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockScheduler_AnnounceCachePeerClient) Send(arg0 *scheduler.AnnounceCachePeerRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockScheduler_AnnounceCachePeerClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockScheduler_AnnounceCachePeerClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_AnnounceCachePeerClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnounceCachePeerClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockScheduler_AnnounceCachePeerClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

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

// MockScheduler_AnnouncePersistentPeerClient is a mock of Scheduler_AnnouncePersistentPeerClient interface.
type MockScheduler_AnnouncePersistentPeerClient struct {
	ctrl     *gomock.Controller
	recorder *MockScheduler_AnnouncePersistentPeerClientMockRecorder
	isgomock struct{}
}

// MockScheduler_AnnouncePersistentPeerClientMockRecorder is the mock recorder for MockScheduler_AnnouncePersistentPeerClient.
type MockScheduler_AnnouncePersistentPeerClientMockRecorder struct {
	mock *MockScheduler_AnnouncePersistentPeerClient
}

// NewMockScheduler_AnnouncePersistentPeerClient creates a new mock instance.
func NewMockScheduler_AnnouncePersistentPeerClient(ctrl *gomock.Controller) *MockScheduler_AnnouncePersistentPeerClient {
	mock := &MockScheduler_AnnouncePersistentPeerClient{ctrl: ctrl}
	mock.recorder = &MockScheduler_AnnouncePersistentPeerClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerClient) Recv() (*scheduler.AnnouncePersistentPeerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*scheduler.AnnouncePersistentPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePersistentPeerClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_AnnouncePersistentPeerClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerClient) Send(arg0 *scheduler.AnnouncePersistentPeerRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockScheduler_AnnouncePersistentPeerClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePersistentPeerClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_AnnouncePersistentPeerClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

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

// MockScheduler_AnnouncePersistentCachePeerClient is a mock of Scheduler_AnnouncePersistentCachePeerClient interface.
type MockScheduler_AnnouncePersistentCachePeerClient struct {
	ctrl     *gomock.Controller
	recorder *MockScheduler_AnnouncePersistentCachePeerClientMockRecorder
	isgomock struct{}
}

// MockScheduler_AnnouncePersistentCachePeerClientMockRecorder is the mock recorder for MockScheduler_AnnouncePersistentCachePeerClient.
type MockScheduler_AnnouncePersistentCachePeerClientMockRecorder struct {
	mock *MockScheduler_AnnouncePersistentCachePeerClient
}

// NewMockScheduler_AnnouncePersistentCachePeerClient creates a new mock instance.
func NewMockScheduler_AnnouncePersistentCachePeerClient(ctrl *gomock.Controller) *MockScheduler_AnnouncePersistentCachePeerClient {
	mock := &MockScheduler_AnnouncePersistentCachePeerClient{ctrl: ctrl}
	mock.recorder = &MockScheduler_AnnouncePersistentCachePeerClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Header mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Recv mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerClient) Recv() (*scheduler.AnnouncePersistentCachePeerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*scheduler.AnnouncePersistentCachePeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePersistentCachePeerClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_AnnouncePersistentCachePeerClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerClient) Send(arg0 *scheduler.AnnouncePersistentCachePeerRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockScheduler_AnnouncePersistentCachePeerClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePersistentCachePeerClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_AnnouncePersistentCachePeerClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

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

// MockSchedulerServer is a mock of SchedulerServer interface.
type MockSchedulerServer struct {
	ctrl     *gomock.Controller
	recorder *MockSchedulerServerMockRecorder
	isgomock struct{}
}

// MockSchedulerServerMockRecorder is the mock recorder for MockSchedulerServer.
type MockSchedulerServerMockRecorder struct {
	mock *MockSchedulerServer
}

// NewMockSchedulerServer creates a new mock instance.
func NewMockSchedulerServer(ctrl *gomock.Controller) *MockSchedulerServer {
	mock := &MockSchedulerServer{ctrl: ctrl}
	mock.recorder = &MockSchedulerServerMockRecorder{mock}
	return mock
}

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

// AnnounceCachePeer mocks base method.
func (m *MockSchedulerServer) AnnounceCachePeer(arg0 scheduler.Scheduler_AnnounceCachePeerServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AnnounceCachePeer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// AnnounceCachePeer indicates an expected call of AnnounceCachePeer.
func (mr *MockSchedulerServerMockRecorder) AnnounceCachePeer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).AnnounceCachePeer), arg0)
}

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

// AnnounceHost indicates an expected call of AnnounceHost.
func (mr *MockSchedulerServerMockRecorder) AnnounceHost(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceHost", reflect.TypeOf((*MockSchedulerServer)(nil).AnnounceHost), arg0, arg1)
}

// AnnouncePeer mocks base method.
func (m *MockSchedulerServer) AnnouncePeer(arg0 scheduler.Scheduler_AnnouncePeerServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AnnouncePeer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// AnnouncePeer indicates an expected call of AnnouncePeer.
func (mr *MockSchedulerServerMockRecorder) AnnouncePeer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnouncePeer", reflect.TypeOf((*MockSchedulerServer)(nil).AnnouncePeer), arg0)
}

// AnnouncePersistentCachePeer mocks base method.
func (m *MockSchedulerServer) AnnouncePersistentCachePeer(arg0 scheduler.Scheduler_AnnouncePersistentCachePeerServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AnnouncePersistentCachePeer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// AnnouncePersistentCachePeer indicates an expected call of AnnouncePersistentCachePeer.
func (mr *MockSchedulerServerMockRecorder) AnnouncePersistentCachePeer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnouncePersistentCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).AnnouncePersistentCachePeer), arg0)
}

// AnnouncePersistentPeer mocks base method.
func (m *MockSchedulerServer) AnnouncePersistentPeer(arg0 scheduler.Scheduler_AnnouncePersistentPeerServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AnnouncePersistentPeer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// AnnouncePersistentPeer indicates an expected call of AnnouncePersistentPeer.
func (mr *MockSchedulerServerMockRecorder) AnnouncePersistentPeer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnouncePersistentPeer", reflect.TypeOf((*MockSchedulerServer)(nil).AnnouncePersistentPeer), arg0)
}

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

// DeleteCachePeer indicates an expected call of DeleteCachePeer.
func (mr *MockSchedulerServerMockRecorder) DeleteCachePeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).DeleteCachePeer), arg0, arg1)
}

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

// DeleteCacheTask indicates an expected call of DeleteCacheTask.
func (mr *MockSchedulerServerMockRecorder) DeleteCacheTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheTask", reflect.TypeOf((*MockSchedulerServer)(nil).DeleteCacheTask), arg0, arg1)
}

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

// DeleteHost indicates an expected call of DeleteHost.
func (mr *MockSchedulerServerMockRecorder) DeleteHost(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHost", reflect.TypeOf((*MockSchedulerServer)(nil).DeleteHost), arg0, arg1)
}

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

// DeletePeer indicates an expected call of DeletePeer.
func (mr *MockSchedulerServerMockRecorder) DeletePeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePeer", reflect.TypeOf((*MockSchedulerServer)(nil).DeletePeer), arg0, arg1)
}

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

// DeletePersistentCachePeer indicates an expected call of DeletePersistentCachePeer.
func (mr *MockSchedulerServerMockRecorder) DeletePersistentCachePeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).DeletePersistentCachePeer), arg0, arg1)
}

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

// DeletePersistentCacheTask indicates an expected call of DeletePersistentCacheTask.
func (mr *MockSchedulerServerMockRecorder) DeletePersistentCacheTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentCacheTask", reflect.TypeOf((*MockSchedulerServer)(nil).DeletePersistentCacheTask), arg0, arg1)
}

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

// DeletePersistentPeer indicates an expected call of DeletePersistentPeer.
func (mr *MockSchedulerServerMockRecorder) DeletePersistentPeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentPeer", reflect.TypeOf((*MockSchedulerServer)(nil).DeletePersistentPeer), arg0, arg1)
}

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

// DeletePersistentTask indicates an expected call of DeletePersistentTask.
func (mr *MockSchedulerServerMockRecorder) DeletePersistentTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentTask", reflect.TypeOf((*MockSchedulerServer)(nil).DeletePersistentTask), arg0, arg1)
}

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

// DeleteTask indicates an expected call of DeleteTask.
func (mr *MockSchedulerServerMockRecorder) DeleteTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTask", reflect.TypeOf((*MockSchedulerServer)(nil).DeleteTask), arg0, arg1)
}

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

// ListHosts indicates an expected call of ListHosts.
func (mr *MockSchedulerServerMockRecorder) ListHosts(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHosts", reflect.TypeOf((*MockSchedulerServer)(nil).ListHosts), arg0, arg1)
}

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

// PreheatFile indicates an expected call of PreheatFile.
func (mr *MockSchedulerServerMockRecorder) PreheatFile(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreheatFile", reflect.TypeOf((*MockSchedulerServer)(nil).PreheatFile), arg0, arg1)
}

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

// PreheatImage indicates an expected call of PreheatImage.
func (mr *MockSchedulerServerMockRecorder) PreheatImage(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreheatImage", reflect.TypeOf((*MockSchedulerServer)(nil).PreheatImage), arg0, arg1)
}

// StatCachePeer mocks base method.
func (m *MockSchedulerServer) StatCachePeer(arg0 context.Context, arg1 *scheduler.StatCachePeerRequest) (*common.CachePeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatCachePeer", arg0, arg1)
	ret0, _ := ret[0].(*common.CachePeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatCachePeer indicates an expected call of StatCachePeer.
func (mr *MockSchedulerServerMockRecorder) StatCachePeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).StatCachePeer), arg0, arg1)
}

// StatCacheTask mocks base method.
func (m *MockSchedulerServer) StatCacheTask(arg0 context.Context, arg1 *scheduler.StatCacheTaskRequest) (*common.CacheTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatCacheTask", arg0, arg1)
	ret0, _ := ret[0].(*common.CacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatCacheTask indicates an expected call of StatCacheTask.
func (mr *MockSchedulerServerMockRecorder) StatCacheTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatCacheTask", reflect.TypeOf((*MockSchedulerServer)(nil).StatCacheTask), arg0, arg1)
}

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

// StatFile indicates an expected call of StatFile.
func (mr *MockSchedulerServerMockRecorder) StatFile(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatFile", reflect.TypeOf((*MockSchedulerServer)(nil).StatFile), arg0, arg1)
}

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

// StatImage indicates an expected call of StatImage.
func (mr *MockSchedulerServerMockRecorder) StatImage(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatImage", reflect.TypeOf((*MockSchedulerServer)(nil).StatImage), arg0, arg1)
}

// StatPeer mocks base method.
func (m *MockSchedulerServer) StatPeer(arg0 context.Context, arg1 *scheduler.StatPeerRequest) (*common.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatPeer", arg0, arg1)
	ret0, _ := ret[0].(*common.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatPeer indicates an expected call of StatPeer.
func (mr *MockSchedulerServerMockRecorder) StatPeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPeer", reflect.TypeOf((*MockSchedulerServer)(nil).StatPeer), arg0, arg1)
}

// StatPersistentCachePeer mocks base method.
func (m *MockSchedulerServer) StatPersistentCachePeer(arg0 context.Context, arg1 *scheduler.StatPersistentCachePeerRequest) (*common.PersistentCachePeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatPersistentCachePeer", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentCachePeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatPersistentCachePeer indicates an expected call of StatPersistentCachePeer.
func (mr *MockSchedulerServerMockRecorder) StatPersistentCachePeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPersistentCachePeer", reflect.TypeOf((*MockSchedulerServer)(nil).StatPersistentCachePeer), arg0, arg1)
}

// StatPersistentCacheTask mocks base method.
func (m *MockSchedulerServer) StatPersistentCacheTask(arg0 context.Context, arg1 *scheduler.StatPersistentCacheTaskRequest) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatPersistentCacheTask", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatPersistentCacheTask indicates an expected call of StatPersistentCacheTask.
func (mr *MockSchedulerServerMockRecorder) StatPersistentCacheTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPersistentCacheTask", reflect.TypeOf((*MockSchedulerServer)(nil).StatPersistentCacheTask), arg0, arg1)
}

// StatPersistentPeer mocks base method.
func (m *MockSchedulerServer) StatPersistentPeer(arg0 context.Context, arg1 *scheduler.StatPersistentPeerRequest) (*common.PersistentPeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatPersistentPeer", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatPersistentPeer indicates an expected call of StatPersistentPeer.
func (mr *MockSchedulerServerMockRecorder) StatPersistentPeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPersistentPeer", reflect.TypeOf((*MockSchedulerServer)(nil).StatPersistentPeer), arg0, arg1)
}

// StatPersistentTask mocks base method.
func (m *MockSchedulerServer) StatPersistentTask(arg0 context.Context, arg1 *scheduler.StatPersistentTaskRequest) (*common.PersistentTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatPersistentTask", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatPersistentTask indicates an expected call of StatPersistentTask.
func (mr *MockSchedulerServerMockRecorder) StatPersistentTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatPersistentTask", reflect.TypeOf((*MockSchedulerServer)(nil).StatPersistentTask), arg0, arg1)
}

// StatTask mocks base method.
func (m *MockSchedulerServer) StatTask(arg0 context.Context, arg1 *scheduler.StatTaskRequest) (*common.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatTask", arg0, arg1)
	ret0, _ := ret[0].(*common.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StatTask indicates an expected call of StatTask.
func (mr *MockSchedulerServerMockRecorder) StatTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatTask", reflect.TypeOf((*MockSchedulerServer)(nil).StatTask), arg0, arg1)
}

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

// UploadPersistentCacheTaskFailed indicates an expected call of UploadPersistentCacheTaskFailed.
func (mr *MockSchedulerServerMockRecorder) UploadPersistentCacheTaskFailed(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPersistentCacheTaskFailed", reflect.TypeOf((*MockSchedulerServer)(nil).UploadPersistentCacheTaskFailed), arg0, arg1)
}

// UploadPersistentCacheTaskFinished mocks base method.
func (m *MockSchedulerServer) UploadPersistentCacheTaskFinished(arg0 context.Context, arg1 *scheduler.UploadPersistentCacheTaskFinishedRequest) (*common.PersistentCacheTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadPersistentCacheTaskFinished", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentCacheTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadPersistentCacheTaskFinished indicates an expected call of UploadPersistentCacheTaskFinished.
func (mr *MockSchedulerServerMockRecorder) UploadPersistentCacheTaskFinished(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPersistentCacheTaskFinished", reflect.TypeOf((*MockSchedulerServer)(nil).UploadPersistentCacheTaskFinished), arg0, arg1)
}

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

// UploadPersistentCacheTaskStarted indicates an expected call of UploadPersistentCacheTaskStarted.
func (mr *MockSchedulerServerMockRecorder) UploadPersistentCacheTaskStarted(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPersistentCacheTaskStarted", reflect.TypeOf((*MockSchedulerServer)(nil).UploadPersistentCacheTaskStarted), arg0, arg1)
}

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

// UploadPersistentTaskFailed indicates an expected call of UploadPersistentTaskFailed.
func (mr *MockSchedulerServerMockRecorder) UploadPersistentTaskFailed(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPersistentTaskFailed", reflect.TypeOf((*MockSchedulerServer)(nil).UploadPersistentTaskFailed), arg0, arg1)
}

// UploadPersistentTaskFinished mocks base method.
func (m *MockSchedulerServer) UploadPersistentTaskFinished(arg0 context.Context, arg1 *scheduler.UploadPersistentTaskFinishedRequest) (*common.PersistentTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadPersistentTaskFinished", arg0, arg1)
	ret0, _ := ret[0].(*common.PersistentTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadPersistentTaskFinished indicates an expected call of UploadPersistentTaskFinished.
func (mr *MockSchedulerServerMockRecorder) UploadPersistentTaskFinished(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPersistentTaskFinished", reflect.TypeOf((*MockSchedulerServer)(nil).UploadPersistentTaskFinished), arg0, arg1)
}

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

// UploadPersistentTaskStarted indicates an expected call of UploadPersistentTaskStarted.
func (mr *MockSchedulerServerMockRecorder) UploadPersistentTaskStarted(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPersistentTaskStarted", reflect.TypeOf((*MockSchedulerServer)(nil).UploadPersistentTaskStarted), arg0, arg1)
}

// MockUnsafeSchedulerServer is a mock of UnsafeSchedulerServer interface.
type MockUnsafeSchedulerServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeSchedulerServerMockRecorder
	isgomock struct{}
}

// MockUnsafeSchedulerServerMockRecorder is the mock recorder for MockUnsafeSchedulerServer.
type MockUnsafeSchedulerServerMockRecorder struct {
	mock *MockUnsafeSchedulerServer
}

// NewMockUnsafeSchedulerServer creates a new mock instance.
func NewMockUnsafeSchedulerServer(ctrl *gomock.Controller) *MockUnsafeSchedulerServer {
	mock := &MockUnsafeSchedulerServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeSchedulerServerMockRecorder{mock}
	return mock
}

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

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

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

// MockScheduler_AnnouncePeerServer is a mock of Scheduler_AnnouncePeerServer interface.
type MockScheduler_AnnouncePeerServer struct {
	ctrl     *gomock.Controller
	recorder *MockScheduler_AnnouncePeerServerMockRecorder
	isgomock struct{}
}

// MockScheduler_AnnouncePeerServerMockRecorder is the mock recorder for MockScheduler_AnnouncePeerServer.
type MockScheduler_AnnouncePeerServerMockRecorder struct {
	mock *MockScheduler_AnnouncePeerServer
}

// NewMockScheduler_AnnouncePeerServer creates a new mock instance.
func NewMockScheduler_AnnouncePeerServer(ctrl *gomock.Controller) *MockScheduler_AnnouncePeerServer {
	mock := &MockScheduler_AnnouncePeerServer{ctrl: ctrl}
	mock.recorder = &MockScheduler_AnnouncePeerServerMockRecorder{mock}
	return mock
}

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

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

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

// Recv mocks base method.
func (m *MockScheduler_AnnouncePeerServer) Recv() (*scheduler.AnnouncePeerRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*scheduler.AnnouncePeerRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePeerServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_AnnouncePeerServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockScheduler_AnnouncePeerServer) Send(arg0 *scheduler.AnnouncePeerResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockScheduler_AnnouncePeerServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockScheduler_AnnouncePeerServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockScheduler_AnnouncePeerServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePeerServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_AnnouncePeerServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockScheduler_AnnouncePeerServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockScheduler_AnnouncePeerServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockScheduler_AnnouncePeerServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockScheduler_AnnouncePeerServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_AnnouncePeerServer)(nil).SetTrailer), arg0)
}

// MockScheduler_AnnounceCachePeerServer is a mock of Scheduler_AnnounceCachePeerServer interface.
type MockScheduler_AnnounceCachePeerServer struct {
	ctrl     *gomock.Controller
	recorder *MockScheduler_AnnounceCachePeerServerMockRecorder
	isgomock struct{}
}

// MockScheduler_AnnounceCachePeerServerMockRecorder is the mock recorder for MockScheduler_AnnounceCachePeerServer.
type MockScheduler_AnnounceCachePeerServerMockRecorder struct {
	mock *MockScheduler_AnnounceCachePeerServer
}

// NewMockScheduler_AnnounceCachePeerServer creates a new mock instance.
func NewMockScheduler_AnnounceCachePeerServer(ctrl *gomock.Controller) *MockScheduler_AnnounceCachePeerServer {
	mock := &MockScheduler_AnnounceCachePeerServer{ctrl: ctrl}
	mock.recorder = &MockScheduler_AnnounceCachePeerServerMockRecorder{mock}
	return mock
}

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

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

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

// Recv mocks base method.
func (m *MockScheduler_AnnounceCachePeerServer) Recv() (*scheduler.AnnounceCachePeerRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*scheduler.AnnounceCachePeerRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockScheduler_AnnounceCachePeerServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_AnnounceCachePeerServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockScheduler_AnnounceCachePeerServer) Send(arg0 *scheduler.AnnounceCachePeerResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockScheduler_AnnounceCachePeerServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockScheduler_AnnounceCachePeerServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockScheduler_AnnounceCachePeerServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockScheduler_AnnounceCachePeerServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_AnnounceCachePeerServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockScheduler_AnnounceCachePeerServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockScheduler_AnnounceCachePeerServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockScheduler_AnnounceCachePeerServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockScheduler_AnnounceCachePeerServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_AnnounceCachePeerServer)(nil).SetTrailer), arg0)
}

// MockScheduler_AnnouncePersistentPeerServer is a mock of Scheduler_AnnouncePersistentPeerServer interface.
type MockScheduler_AnnouncePersistentPeerServer struct {
	ctrl     *gomock.Controller
	recorder *MockScheduler_AnnouncePersistentPeerServerMockRecorder
	isgomock struct{}
}

// MockScheduler_AnnouncePersistentPeerServerMockRecorder is the mock recorder for MockScheduler_AnnouncePersistentPeerServer.
type MockScheduler_AnnouncePersistentPeerServerMockRecorder struct {
	mock *MockScheduler_AnnouncePersistentPeerServer
}

// NewMockScheduler_AnnouncePersistentPeerServer creates a new mock instance.
func NewMockScheduler_AnnouncePersistentPeerServer(ctrl *gomock.Controller) *MockScheduler_AnnouncePersistentPeerServer {
	mock := &MockScheduler_AnnouncePersistentPeerServer{ctrl: ctrl}
	mock.recorder = &MockScheduler_AnnouncePersistentPeerServerMockRecorder{mock}
	return mock
}

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

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

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

// Recv mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerServer) Recv() (*scheduler.AnnouncePersistentPeerRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*scheduler.AnnouncePersistentPeerRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePersistentPeerServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_AnnouncePersistentPeerServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerServer) Send(arg0 *scheduler.AnnouncePersistentPeerResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockScheduler_AnnouncePersistentPeerServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockScheduler_AnnouncePersistentPeerServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePersistentPeerServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_AnnouncePersistentPeerServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockScheduler_AnnouncePersistentPeerServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockScheduler_AnnouncePersistentPeerServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockScheduler_AnnouncePersistentPeerServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_AnnouncePersistentPeerServer)(nil).SetTrailer), arg0)
}

// MockScheduler_AnnouncePersistentCachePeerServer is a mock of Scheduler_AnnouncePersistentCachePeerServer interface.
type MockScheduler_AnnouncePersistentCachePeerServer struct {
	ctrl     *gomock.Controller
	recorder *MockScheduler_AnnouncePersistentCachePeerServerMockRecorder
	isgomock struct{}
}

// MockScheduler_AnnouncePersistentCachePeerServerMockRecorder is the mock recorder for MockScheduler_AnnouncePersistentCachePeerServer.
type MockScheduler_AnnouncePersistentCachePeerServerMockRecorder struct {
	mock *MockScheduler_AnnouncePersistentCachePeerServer
}

// NewMockScheduler_AnnouncePersistentCachePeerServer creates a new mock instance.
func NewMockScheduler_AnnouncePersistentCachePeerServer(ctrl *gomock.Controller) *MockScheduler_AnnouncePersistentCachePeerServer {
	mock := &MockScheduler_AnnouncePersistentCachePeerServer{ctrl: ctrl}
	mock.recorder = &MockScheduler_AnnouncePersistentCachePeerServerMockRecorder{mock}
	return mock
}

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

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

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

// Recv mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerServer) Recv() (*scheduler.AnnouncePersistentCachePeerRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*scheduler.AnnouncePersistentCachePeerRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecvMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePersistentCachePeerServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_AnnouncePersistentCachePeerServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerServer) Send(arg0 *scheduler.AnnouncePersistentCachePeerResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockScheduler_AnnouncePersistentCachePeerServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockScheduler_AnnouncePersistentCachePeerServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockScheduler_AnnouncePersistentCachePeerServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_AnnouncePersistentCachePeerServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockScheduler_AnnouncePersistentCachePeerServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockScheduler_AnnouncePersistentCachePeerServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockScheduler_AnnouncePersistentCachePeerServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_AnnouncePersistentCachePeerServer)(nil).SetTrailer), arg0)
}
