grpc_service_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ../grpc_service_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -destination grpc_service_mock.go -source ../grpc_service_grpc.pb.go -package mocks
//
// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	reflect "reflect"

	inference "d7y.io/api/v2/pkg/apis/inference"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)

// MockGRPCInferenceServiceClient is a mock of GRPCInferenceServiceClient interface.
type MockGRPCInferenceServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockGRPCInferenceServiceClientMockRecorder
}

// MockGRPCInferenceServiceClientMockRecorder is the mock recorder for MockGRPCInferenceServiceClient.
type MockGRPCInferenceServiceClientMockRecorder struct {
	mock *MockGRPCInferenceServiceClient
}

// NewMockGRPCInferenceServiceClient creates a new mock instance.
func NewMockGRPCInferenceServiceClient(ctrl *gomock.Controller) *MockGRPCInferenceServiceClient {
	mock := &MockGRPCInferenceServiceClient{ctrl: ctrl}
	mock.recorder = &MockGRPCInferenceServiceClientMockRecorder{mock}
	return mock
}

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

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

// CudaSharedMemoryRegister indicates an expected call of CudaSharedMemoryRegister.
func (mr *MockGRPCInferenceServiceClientMockRecorder) CudaSharedMemoryRegister(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, "CudaSharedMemoryRegister", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).CudaSharedMemoryRegister), varargs...)
}

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

// CudaSharedMemoryStatus indicates an expected call of CudaSharedMemoryStatus.
func (mr *MockGRPCInferenceServiceClientMockRecorder) CudaSharedMemoryStatus(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, "CudaSharedMemoryStatus", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).CudaSharedMemoryStatus), varargs...)
}

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

// CudaSharedMemoryUnregister indicates an expected call of CudaSharedMemoryUnregister.
func (mr *MockGRPCInferenceServiceClientMockRecorder) CudaSharedMemoryUnregister(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, "CudaSharedMemoryUnregister", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).CudaSharedMemoryUnregister), varargs...)
}

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

// LogSettings indicates an expected call of LogSettings.
func (mr *MockGRPCInferenceServiceClientMockRecorder) LogSettings(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, "LogSettings", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).LogSettings), varargs...)
}

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

// ModelConfig indicates an expected call of ModelConfig.
func (mr *MockGRPCInferenceServiceClientMockRecorder) ModelConfig(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, "ModelConfig", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).ModelConfig), varargs...)
}

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

// ModelInfer indicates an expected call of ModelInfer.
func (mr *MockGRPCInferenceServiceClientMockRecorder) ModelInfer(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, "ModelInfer", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).ModelInfer), varargs...)
}

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

// ModelMetadata indicates an expected call of ModelMetadata.
func (mr *MockGRPCInferenceServiceClientMockRecorder) ModelMetadata(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, "ModelMetadata", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).ModelMetadata), varargs...)
}

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

// ModelReady indicates an expected call of ModelReady.
func (mr *MockGRPCInferenceServiceClientMockRecorder) ModelReady(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, "ModelReady", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).ModelReady), varargs...)
}

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

// ModelStatistics indicates an expected call of ModelStatistics.
func (mr *MockGRPCInferenceServiceClientMockRecorder) ModelStatistics(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, "ModelStatistics", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).ModelStatistics), varargs...)
}

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

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

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

// RepositoryIndex indicates an expected call of RepositoryIndex.
func (mr *MockGRPCInferenceServiceClientMockRecorder) RepositoryIndex(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, "RepositoryIndex", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).RepositoryIndex), varargs...)
}

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

// RepositoryModelLoad indicates an expected call of RepositoryModelLoad.
func (mr *MockGRPCInferenceServiceClientMockRecorder) RepositoryModelLoad(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, "RepositoryModelLoad", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).RepositoryModelLoad), varargs...)
}

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

// RepositoryModelUnload indicates an expected call of RepositoryModelUnload.
func (mr *MockGRPCInferenceServiceClientMockRecorder) RepositoryModelUnload(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, "RepositoryModelUnload", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).RepositoryModelUnload), varargs...)
}

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

// ServerLive indicates an expected call of ServerLive.
func (mr *MockGRPCInferenceServiceClientMockRecorder) ServerLive(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, "ServerLive", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).ServerLive), varargs...)
}

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

// ServerMetadata indicates an expected call of ServerMetadata.
func (mr *MockGRPCInferenceServiceClientMockRecorder) ServerMetadata(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, "ServerMetadata", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).ServerMetadata), varargs...)
}

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

// ServerReady indicates an expected call of ServerReady.
func (mr *MockGRPCInferenceServiceClientMockRecorder) ServerReady(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, "ServerReady", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).ServerReady), varargs...)
}

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

// SystemSharedMemoryRegister indicates an expected call of SystemSharedMemoryRegister.
func (mr *MockGRPCInferenceServiceClientMockRecorder) SystemSharedMemoryRegister(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, "SystemSharedMemoryRegister", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).SystemSharedMemoryRegister), varargs...)
}

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

// SystemSharedMemoryStatus indicates an expected call of SystemSharedMemoryStatus.
func (mr *MockGRPCInferenceServiceClientMockRecorder) SystemSharedMemoryStatus(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, "SystemSharedMemoryStatus", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).SystemSharedMemoryStatus), varargs...)
}

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

// SystemSharedMemoryUnregister indicates an expected call of SystemSharedMemoryUnregister.
func (mr *MockGRPCInferenceServiceClientMockRecorder) SystemSharedMemoryUnregister(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, "SystemSharedMemoryUnregister", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).SystemSharedMemoryUnregister), varargs...)
}

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

// TraceSetting indicates an expected call of TraceSetting.
func (mr *MockGRPCInferenceServiceClientMockRecorder) TraceSetting(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, "TraceSetting", reflect.TypeOf((*MockGRPCInferenceServiceClient)(nil).TraceSetting), varargs...)
}

// MockGRPCInferenceService_ModelStreamInferClient is a mock of GRPCInferenceService_ModelStreamInferClient interface.
type MockGRPCInferenceService_ModelStreamInferClient struct {
	ctrl     *gomock.Controller
	recorder *MockGRPCInferenceService_ModelStreamInferClientMockRecorder
}

// MockGRPCInferenceService_ModelStreamInferClientMockRecorder is the mock recorder for MockGRPCInferenceService_ModelStreamInferClient.
type MockGRPCInferenceService_ModelStreamInferClientMockRecorder struct {
	mock *MockGRPCInferenceService_ModelStreamInferClient
}

// NewMockGRPCInferenceService_ModelStreamInferClient creates a new mock instance.
func NewMockGRPCInferenceService_ModelStreamInferClient(ctrl *gomock.Controller) *MockGRPCInferenceService_ModelStreamInferClient {
	mock := &MockGRPCInferenceService_ModelStreamInferClient{ctrl: ctrl}
	mock.recorder = &MockGRPCInferenceService_ModelStreamInferClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferClient) 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 *MockGRPCInferenceService_ModelStreamInferClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferClient) 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 *MockGRPCInferenceService_ModelStreamInferClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferClient)(nil).Context))
}

// Header mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferClient) 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 *MockGRPCInferenceService_ModelStreamInferClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferClient)(nil).Header))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockGRPCInferenceService_ModelStreamInferClient) 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 *MockGRPCInferenceService_ModelStreamInferClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferClient) Send(arg0 *inference.ModelInferRequest) 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 *MockGRPCInferenceService_ModelStreamInferClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockGRPCInferenceService_ModelStreamInferClient) 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 *MockGRPCInferenceService_ModelStreamInferClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferClient) 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 *MockGRPCInferenceService_ModelStreamInferClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferClient)(nil).Trailer))
}

// MockGRPCInferenceServiceServer is a mock of GRPCInferenceServiceServer interface.
type MockGRPCInferenceServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockGRPCInferenceServiceServerMockRecorder
}

// MockGRPCInferenceServiceServerMockRecorder is the mock recorder for MockGRPCInferenceServiceServer.
type MockGRPCInferenceServiceServerMockRecorder struct {
	mock *MockGRPCInferenceServiceServer
}

// NewMockGRPCInferenceServiceServer creates a new mock instance.
func NewMockGRPCInferenceServiceServer(ctrl *gomock.Controller) *MockGRPCInferenceServiceServer {
	mock := &MockGRPCInferenceServiceServer{ctrl: ctrl}
	mock.recorder = &MockGRPCInferenceServiceServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockUnsafeGRPCInferenceServiceServer is a mock of UnsafeGRPCInferenceServiceServer interface.
type MockUnsafeGRPCInferenceServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeGRPCInferenceServiceServerMockRecorder
}

// MockUnsafeGRPCInferenceServiceServerMockRecorder is the mock recorder for MockUnsafeGRPCInferenceServiceServer.
type MockUnsafeGRPCInferenceServiceServerMockRecorder struct {
	mock *MockUnsafeGRPCInferenceServiceServer
}

// NewMockUnsafeGRPCInferenceServiceServer creates a new mock instance.
func NewMockUnsafeGRPCInferenceServiceServer(ctrl *gomock.Controller) *MockUnsafeGRPCInferenceServiceServer {
	mock := &MockUnsafeGRPCInferenceServiceServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeGRPCInferenceServiceServerMockRecorder{mock}
	return mock
}

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

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

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

// MockGRPCInferenceService_ModelStreamInferServer is a mock of GRPCInferenceService_ModelStreamInferServer interface.
type MockGRPCInferenceService_ModelStreamInferServer struct {
	ctrl     *gomock.Controller
	recorder *MockGRPCInferenceService_ModelStreamInferServerMockRecorder
}

// MockGRPCInferenceService_ModelStreamInferServerMockRecorder is the mock recorder for MockGRPCInferenceService_ModelStreamInferServer.
type MockGRPCInferenceService_ModelStreamInferServerMockRecorder struct {
	mock *MockGRPCInferenceService_ModelStreamInferServer
}

// NewMockGRPCInferenceService_ModelStreamInferServer creates a new mock instance.
func NewMockGRPCInferenceService_ModelStreamInferServer(ctrl *gomock.Controller) *MockGRPCInferenceService_ModelStreamInferServer {
	mock := &MockGRPCInferenceService_ModelStreamInferServer{ctrl: ctrl}
	mock.recorder = &MockGRPCInferenceService_ModelStreamInferServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferServer) 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 *MockGRPCInferenceService_ModelStreamInferServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferServer)(nil).Context))
}

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

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

// RecvMsg mocks base method.
func (m_2 *MockGRPCInferenceService_ModelStreamInferServer) 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 *MockGRPCInferenceService_ModelStreamInferServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferServer) Send(arg0 *inference.ModelStreamInferResponse) 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 *MockGRPCInferenceService_ModelStreamInferServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferServer) 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 *MockGRPCInferenceService_ModelStreamInferServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockGRPCInferenceService_ModelStreamInferServer) 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 *MockGRPCInferenceService_ModelStreamInferServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockGRPCInferenceService_ModelStreamInferServer) 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 *MockGRPCInferenceService_ModelStreamInferServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockGRPCInferenceService_ModelStreamInferServer)(nil).SetHeader), arg0)
}

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

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