api-testing/pkg/server/server_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v4.25.1
// source: pkg/server/server.proto

package server

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// RunnerClient is the client API for Runner service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type RunnerClient interface {
	// belong to a specific store
	Run(ctx context.Context, in *TestTask, opts ...grpc.CallOption) (*TestResult, error)
	RunTestSuite(ctx context.Context, opts ...grpc.CallOption) (Runner_RunTestSuiteClient, error)
	// test suites related
	GetSuites(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Suites, error)
	CreateTestSuite(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*HelloReply, error)
	ImportTestSuite(ctx context.Context, in *TestSuiteSource, opts ...grpc.CallOption) (*CommonResult, error)
	GetTestSuite(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*TestSuite, error)
	UpdateTestSuite(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*HelloReply, error)
	DeleteTestSuite(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*HelloReply, error)
	DuplicateTestSuite(ctx context.Context, in *TestSuiteDuplicate, opts ...grpc.CallOption) (*HelloReply, error)
	RenameTestSuite(ctx context.Context, in *TestSuiteDuplicate, opts ...grpc.CallOption) (*HelloReply, error)
	GetTestSuiteYaml(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*YamlData, error)
	// test cases related
	ListTestCase(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*Suite, error)
	// run target test case of a specific test suite
	RunTestCase(ctx context.Context, in *TestCaseIdentity, opts ...grpc.CallOption) (*TestCaseResult, error)
	BatchRun(ctx context.Context, opts ...grpc.CallOption) (Runner_BatchRunClient, error)
	GetTestCase(ctx context.Context, in *TestCaseIdentity, opts ...grpc.CallOption) (*TestCase, error)
	CreateTestCase(ctx context.Context, in *TestCaseWithSuite, opts ...grpc.CallOption) (*HelloReply, error)
	UpdateTestCase(ctx context.Context, in *TestCaseWithSuite, opts ...grpc.CallOption) (*HelloReply, error)
	DeleteTestCase(ctx context.Context, in *TestCaseIdentity, opts ...grpc.CallOption) (*HelloReply, error)
	DuplicateTestCase(ctx context.Context, in *TestCaseDuplicate, opts ...grpc.CallOption) (*HelloReply, error)
	RenameTestCase(ctx context.Context, in *TestCaseDuplicate, opts ...grpc.CallOption) (*HelloReply, error)
	GetSuggestedAPIs(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*TestCases, error)
	// history test related
	GetHistorySuites(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*HistorySuites, error)
	GetHistoryTestCaseWithResult(ctx context.Context, in *HistoryTestCase, opts ...grpc.CallOption) (*HistoryTestResult, error)
	GetHistoryTestCase(ctx context.Context, in *HistoryTestCase, opts ...grpc.CallOption) (*HistoryTestCase, error)
	DeleteHistoryTestCase(ctx context.Context, in *HistoryTestCase, opts ...grpc.CallOption) (*HelloReply, error)
	DeleteAllHistoryTestCase(ctx context.Context, in *HistoryTestCase, opts ...grpc.CallOption) (*HelloReply, error)
	GetTestCaseAllHistory(ctx context.Context, in *TestCase, opts ...grpc.CallOption) (*HistoryTestCases, error)
	// code generator
	ListCodeGenerator(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SimpleList, error)
	GenerateCode(ctx context.Context, in *CodeGenerateRequest, opts ...grpc.CallOption) (*CommonResult, error)
	HistoryGenerateCode(ctx context.Context, in *CodeGenerateRequest, opts ...grpc.CallOption) (*CommonResult, error)
	// converter
	ListConverter(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SimpleList, error)
	ConvertTestSuite(ctx context.Context, in *CodeGenerateRequest, opts ...grpc.CallOption) (*CommonResult, error)
	// common services
	PopularHeaders(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Pairs, error)
	FunctionsQuery(ctx context.Context, in *SimpleQuery, opts ...grpc.CallOption) (*Pairs, error)
	FunctionsQueryStream(ctx context.Context, opts ...grpc.CallOption) (Runner_FunctionsQueryStreamClient, error)
	GetVersion(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Version, error)
	Sample(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*HelloReply, error)
	DownloadResponseFile(ctx context.Context, in *TestCase, opts ...grpc.CallOption) (*FileData, error)
	// stores related interfaces
	GetStoreKinds(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StoreKinds, error)
	GetStores(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Stores, error)
	CreateStore(ctx context.Context, in *Store, opts ...grpc.CallOption) (*Store, error)
	UpdateStore(ctx context.Context, in *Store, opts ...grpc.CallOption) (*Store, error)
	DeleteStore(ctx context.Context, in *Store, opts ...grpc.CallOption) (*Store, error)
	VerifyStore(ctx context.Context, in *SimpleQuery, opts ...grpc.CallOption) (*ExtensionStatus, error)
	// secret related interfaces
	GetSecrets(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Secrets, error)
	CreateSecret(ctx context.Context, in *Secret, opts ...grpc.CallOption) (*CommonResult, error)
	DeleteSecret(ctx context.Context, in *Secret, opts ...grpc.CallOption) (*CommonResult, error)
	UpdateSecret(ctx context.Context, in *Secret, opts ...grpc.CallOption) (*CommonResult, error)
	// extension
	PProf(ctx context.Context, in *PProfRequest, opts ...grpc.CallOption) (*PProfData, error)
}

type runnerClient struct {
	cc grpc.ClientConnInterface
}

func NewRunnerClient(cc grpc.ClientConnInterface) RunnerClient {
	return &runnerClient{cc}
}

func (c *runnerClient) Run(ctx context.Context, in *TestTask, opts ...grpc.CallOption) (*TestResult, error) {
	out := new(TestResult)
	err := c.cc.Invoke(ctx, "/server.Runner/Run", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) RunTestSuite(ctx context.Context, opts ...grpc.CallOption) (Runner_RunTestSuiteClient, error) {
	stream, err := c.cc.NewStream(ctx, &Runner_ServiceDesc.Streams[0], "/server.Runner/RunTestSuite", opts...)
	if err != nil {
		return nil, err
	}
	x := &runnerRunTestSuiteClient{stream}
	return x, nil
}

type Runner_RunTestSuiteClient interface {
	Send(*TestSuiteIdentity) error
	Recv() (*TestResult, error)
	grpc.ClientStream
}

type runnerRunTestSuiteClient struct {
	grpc.ClientStream
}

func (x *runnerRunTestSuiteClient) Send(m *TestSuiteIdentity) error {
	return x.ClientStream.SendMsg(m)
}

func (x *runnerRunTestSuiteClient) Recv() (*TestResult, error) {
	m := new(TestResult)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *runnerClient) GetSuites(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Suites, error) {
	out := new(Suites)
	err := c.cc.Invoke(ctx, "/server.Runner/GetSuites", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) CreateTestSuite(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/CreateTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) ImportTestSuite(ctx context.Context, in *TestSuiteSource, opts ...grpc.CallOption) (*CommonResult, error) {
	out := new(CommonResult)
	err := c.cc.Invoke(ctx, "/server.Runner/ImportTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetTestSuite(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*TestSuite, error) {
	out := new(TestSuite)
	err := c.cc.Invoke(ctx, "/server.Runner/GetTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) UpdateTestSuite(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/UpdateTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DeleteTestSuite(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/DeleteTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DuplicateTestSuite(ctx context.Context, in *TestSuiteDuplicate, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/DuplicateTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) RenameTestSuite(ctx context.Context, in *TestSuiteDuplicate, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/RenameTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetTestSuiteYaml(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*YamlData, error) {
	out := new(YamlData)
	err := c.cc.Invoke(ctx, "/server.Runner/GetTestSuiteYaml", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) ListTestCase(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*Suite, error) {
	out := new(Suite)
	err := c.cc.Invoke(ctx, "/server.Runner/ListTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) RunTestCase(ctx context.Context, in *TestCaseIdentity, opts ...grpc.CallOption) (*TestCaseResult, error) {
	out := new(TestCaseResult)
	err := c.cc.Invoke(ctx, "/server.Runner/RunTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) BatchRun(ctx context.Context, opts ...grpc.CallOption) (Runner_BatchRunClient, error) {
	stream, err := c.cc.NewStream(ctx, &Runner_ServiceDesc.Streams[1], "/server.Runner/BatchRun", opts...)
	if err != nil {
		return nil, err
	}
	x := &runnerBatchRunClient{stream}
	return x, nil
}

type Runner_BatchRunClient interface {
	Send(*BatchTestTask) error
	Recv() (*TestResult, error)
	grpc.ClientStream
}

type runnerBatchRunClient struct {
	grpc.ClientStream
}

func (x *runnerBatchRunClient) Send(m *BatchTestTask) error {
	return x.ClientStream.SendMsg(m)
}

func (x *runnerBatchRunClient) Recv() (*TestResult, error) {
	m := new(TestResult)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *runnerClient) GetTestCase(ctx context.Context, in *TestCaseIdentity, opts ...grpc.CallOption) (*TestCase, error) {
	out := new(TestCase)
	err := c.cc.Invoke(ctx, "/server.Runner/GetTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) CreateTestCase(ctx context.Context, in *TestCaseWithSuite, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/CreateTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) UpdateTestCase(ctx context.Context, in *TestCaseWithSuite, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/UpdateTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DeleteTestCase(ctx context.Context, in *TestCaseIdentity, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/DeleteTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DuplicateTestCase(ctx context.Context, in *TestCaseDuplicate, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/DuplicateTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) RenameTestCase(ctx context.Context, in *TestCaseDuplicate, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/RenameTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetSuggestedAPIs(ctx context.Context, in *TestSuiteIdentity, opts ...grpc.CallOption) (*TestCases, error) {
	out := new(TestCases)
	err := c.cc.Invoke(ctx, "/server.Runner/GetSuggestedAPIs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetHistorySuites(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*HistorySuites, error) {
	out := new(HistorySuites)
	err := c.cc.Invoke(ctx, "/server.Runner/GetHistorySuites", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetHistoryTestCaseWithResult(ctx context.Context, in *HistoryTestCase, opts ...grpc.CallOption) (*HistoryTestResult, error) {
	out := new(HistoryTestResult)
	err := c.cc.Invoke(ctx, "/server.Runner/GetHistoryTestCaseWithResult", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetHistoryTestCase(ctx context.Context, in *HistoryTestCase, opts ...grpc.CallOption) (*HistoryTestCase, error) {
	out := new(HistoryTestCase)
	err := c.cc.Invoke(ctx, "/server.Runner/GetHistoryTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DeleteHistoryTestCase(ctx context.Context, in *HistoryTestCase, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/DeleteHistoryTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DeleteAllHistoryTestCase(ctx context.Context, in *HistoryTestCase, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/DeleteAllHistoryTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetTestCaseAllHistory(ctx context.Context, in *TestCase, opts ...grpc.CallOption) (*HistoryTestCases, error) {
	out := new(HistoryTestCases)
	err := c.cc.Invoke(ctx, "/server.Runner/GetTestCaseAllHistory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) ListCodeGenerator(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SimpleList, error) {
	out := new(SimpleList)
	err := c.cc.Invoke(ctx, "/server.Runner/ListCodeGenerator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GenerateCode(ctx context.Context, in *CodeGenerateRequest, opts ...grpc.CallOption) (*CommonResult, error) {
	out := new(CommonResult)
	err := c.cc.Invoke(ctx, "/server.Runner/GenerateCode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) HistoryGenerateCode(ctx context.Context, in *CodeGenerateRequest, opts ...grpc.CallOption) (*CommonResult, error) {
	out := new(CommonResult)
	err := c.cc.Invoke(ctx, "/server.Runner/HistoryGenerateCode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) ListConverter(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SimpleList, error) {
	out := new(SimpleList)
	err := c.cc.Invoke(ctx, "/server.Runner/ListConverter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) ConvertTestSuite(ctx context.Context, in *CodeGenerateRequest, opts ...grpc.CallOption) (*CommonResult, error) {
	out := new(CommonResult)
	err := c.cc.Invoke(ctx, "/server.Runner/ConvertTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) PopularHeaders(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Pairs, error) {
	out := new(Pairs)
	err := c.cc.Invoke(ctx, "/server.Runner/PopularHeaders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) FunctionsQuery(ctx context.Context, in *SimpleQuery, opts ...grpc.CallOption) (*Pairs, error) {
	out := new(Pairs)
	err := c.cc.Invoke(ctx, "/server.Runner/FunctionsQuery", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) FunctionsQueryStream(ctx context.Context, opts ...grpc.CallOption) (Runner_FunctionsQueryStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &Runner_ServiceDesc.Streams[2], "/server.Runner/FunctionsQueryStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &runnerFunctionsQueryStreamClient{stream}
	return x, nil
}

type Runner_FunctionsQueryStreamClient interface {
	Send(*SimpleQuery) error
	Recv() (*Pairs, error)
	grpc.ClientStream
}

type runnerFunctionsQueryStreamClient struct {
	grpc.ClientStream
}

func (x *runnerFunctionsQueryStreamClient) Send(m *SimpleQuery) error {
	return x.ClientStream.SendMsg(m)
}

func (x *runnerFunctionsQueryStreamClient) Recv() (*Pairs, error) {
	m := new(Pairs)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *runnerClient) GetVersion(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Version, error) {
	out := new(Version)
	err := c.cc.Invoke(ctx, "/server.Runner/GetVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) Sample(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, "/server.Runner/Sample", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DownloadResponseFile(ctx context.Context, in *TestCase, opts ...grpc.CallOption) (*FileData, error) {
	out := new(FileData)
	err := c.cc.Invoke(ctx, "/server.Runner/DownloadResponseFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetStoreKinds(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StoreKinds, error) {
	out := new(StoreKinds)
	err := c.cc.Invoke(ctx, "/server.Runner/GetStoreKinds", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetStores(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Stores, error) {
	out := new(Stores)
	err := c.cc.Invoke(ctx, "/server.Runner/GetStores", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) CreateStore(ctx context.Context, in *Store, opts ...grpc.CallOption) (*Store, error) {
	out := new(Store)
	err := c.cc.Invoke(ctx, "/server.Runner/CreateStore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) UpdateStore(ctx context.Context, in *Store, opts ...grpc.CallOption) (*Store, error) {
	out := new(Store)
	err := c.cc.Invoke(ctx, "/server.Runner/UpdateStore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DeleteStore(ctx context.Context, in *Store, opts ...grpc.CallOption) (*Store, error) {
	out := new(Store)
	err := c.cc.Invoke(ctx, "/server.Runner/DeleteStore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) VerifyStore(ctx context.Context, in *SimpleQuery, opts ...grpc.CallOption) (*ExtensionStatus, error) {
	out := new(ExtensionStatus)
	err := c.cc.Invoke(ctx, "/server.Runner/VerifyStore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) GetSecrets(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Secrets, error) {
	out := new(Secrets)
	err := c.cc.Invoke(ctx, "/server.Runner/GetSecrets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) CreateSecret(ctx context.Context, in *Secret, opts ...grpc.CallOption) (*CommonResult, error) {
	out := new(CommonResult)
	err := c.cc.Invoke(ctx, "/server.Runner/CreateSecret", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) DeleteSecret(ctx context.Context, in *Secret, opts ...grpc.CallOption) (*CommonResult, error) {
	out := new(CommonResult)
	err := c.cc.Invoke(ctx, "/server.Runner/DeleteSecret", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) UpdateSecret(ctx context.Context, in *Secret, opts ...grpc.CallOption) (*CommonResult, error) {
	out := new(CommonResult)
	err := c.cc.Invoke(ctx, "/server.Runner/UpdateSecret", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerClient) PProf(ctx context.Context, in *PProfRequest, opts ...grpc.CallOption) (*PProfData, error) {
	out := new(PProfData)
	err := c.cc.Invoke(ctx, "/server.Runner/PProf", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RunnerServer is the server API for Runner service.
// All implementations must embed UnimplementedRunnerServer
// for forward compatibility
type RunnerServer interface {
	// belong to a specific store
	Run(context.Context, *TestTask) (*TestResult, error)
	RunTestSuite(Runner_RunTestSuiteServer) error
	// test suites related
	GetSuites(context.Context, *Empty) (*Suites, error)
	CreateTestSuite(context.Context, *TestSuiteIdentity) (*HelloReply, error)
	ImportTestSuite(context.Context, *TestSuiteSource) (*CommonResult, error)
	GetTestSuite(context.Context, *TestSuiteIdentity) (*TestSuite, error)
	UpdateTestSuite(context.Context, *TestSuite) (*HelloReply, error)
	DeleteTestSuite(context.Context, *TestSuiteIdentity) (*HelloReply, error)
	DuplicateTestSuite(context.Context, *TestSuiteDuplicate) (*HelloReply, error)
	RenameTestSuite(context.Context, *TestSuiteDuplicate) (*HelloReply, error)
	GetTestSuiteYaml(context.Context, *TestSuiteIdentity) (*YamlData, error)
	// test cases related
	ListTestCase(context.Context, *TestSuiteIdentity) (*Suite, error)
	// run target test case of a specific test suite
	RunTestCase(context.Context, *TestCaseIdentity) (*TestCaseResult, error)
	BatchRun(Runner_BatchRunServer) error
	GetTestCase(context.Context, *TestCaseIdentity) (*TestCase, error)
	CreateTestCase(context.Context, *TestCaseWithSuite) (*HelloReply, error)
	UpdateTestCase(context.Context, *TestCaseWithSuite) (*HelloReply, error)
	DeleteTestCase(context.Context, *TestCaseIdentity) (*HelloReply, error)
	DuplicateTestCase(context.Context, *TestCaseDuplicate) (*HelloReply, error)
	RenameTestCase(context.Context, *TestCaseDuplicate) (*HelloReply, error)
	GetSuggestedAPIs(context.Context, *TestSuiteIdentity) (*TestCases, error)
	// history test related
	GetHistorySuites(context.Context, *Empty) (*HistorySuites, error)
	GetHistoryTestCaseWithResult(context.Context, *HistoryTestCase) (*HistoryTestResult, error)
	GetHistoryTestCase(context.Context, *HistoryTestCase) (*HistoryTestCase, error)
	DeleteHistoryTestCase(context.Context, *HistoryTestCase) (*HelloReply, error)
	DeleteAllHistoryTestCase(context.Context, *HistoryTestCase) (*HelloReply, error)
	GetTestCaseAllHistory(context.Context, *TestCase) (*HistoryTestCases, error)
	// code generator
	ListCodeGenerator(context.Context, *Empty) (*SimpleList, error)
	GenerateCode(context.Context, *CodeGenerateRequest) (*CommonResult, error)
	HistoryGenerateCode(context.Context, *CodeGenerateRequest) (*CommonResult, error)
	// converter
	ListConverter(context.Context, *Empty) (*SimpleList, error)
	ConvertTestSuite(context.Context, *CodeGenerateRequest) (*CommonResult, error)
	// common services
	PopularHeaders(context.Context, *Empty) (*Pairs, error)
	FunctionsQuery(context.Context, *SimpleQuery) (*Pairs, error)
	FunctionsQueryStream(Runner_FunctionsQueryStreamServer) error
	GetVersion(context.Context, *Empty) (*Version, error)
	Sample(context.Context, *Empty) (*HelloReply, error)
	DownloadResponseFile(context.Context, *TestCase) (*FileData, error)
	// stores related interfaces
	GetStoreKinds(context.Context, *Empty) (*StoreKinds, error)
	GetStores(context.Context, *Empty) (*Stores, error)
	CreateStore(context.Context, *Store) (*Store, error)
	UpdateStore(context.Context, *Store) (*Store, error)
	DeleteStore(context.Context, *Store) (*Store, error)
	VerifyStore(context.Context, *SimpleQuery) (*ExtensionStatus, error)
	// secret related interfaces
	GetSecrets(context.Context, *Empty) (*Secrets, error)
	CreateSecret(context.Context, *Secret) (*CommonResult, error)
	DeleteSecret(context.Context, *Secret) (*CommonResult, error)
	UpdateSecret(context.Context, *Secret) (*CommonResult, error)
	// extension
	PProf(context.Context, *PProfRequest) (*PProfData, error)
	mustEmbedUnimplementedRunnerServer()
}

// UnimplementedRunnerServer must be embedded to have forward compatible implementations.
type UnimplementedRunnerServer struct {
}

func (UnimplementedRunnerServer) Run(context.Context, *TestTask) (*TestResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Run not implemented")
}
func (UnimplementedRunnerServer) RunTestSuite(Runner_RunTestSuiteServer) error {
	return status.Errorf(codes.Unimplemented, "method RunTestSuite not implemented")
}
func (UnimplementedRunnerServer) GetSuites(context.Context, *Empty) (*Suites, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSuites not implemented")
}
func (UnimplementedRunnerServer) CreateTestSuite(context.Context, *TestSuiteIdentity) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTestSuite not implemented")
}
func (UnimplementedRunnerServer) ImportTestSuite(context.Context, *TestSuiteSource) (*CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportTestSuite not implemented")
}
func (UnimplementedRunnerServer) GetTestSuite(context.Context, *TestSuiteIdentity) (*TestSuite, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestSuite not implemented")
}
func (UnimplementedRunnerServer) UpdateTestSuite(context.Context, *TestSuite) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTestSuite not implemented")
}
func (UnimplementedRunnerServer) DeleteTestSuite(context.Context, *TestSuiteIdentity) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTestSuite not implemented")
}
func (UnimplementedRunnerServer) DuplicateTestSuite(context.Context, *TestSuiteDuplicate) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DuplicateTestSuite not implemented")
}
func (UnimplementedRunnerServer) RenameTestSuite(context.Context, *TestSuiteDuplicate) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenameTestSuite not implemented")
}
func (UnimplementedRunnerServer) GetTestSuiteYaml(context.Context, *TestSuiteIdentity) (*YamlData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestSuiteYaml not implemented")
}
func (UnimplementedRunnerServer) ListTestCase(context.Context, *TestSuiteIdentity) (*Suite, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTestCase not implemented")
}
func (UnimplementedRunnerServer) RunTestCase(context.Context, *TestCaseIdentity) (*TestCaseResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunTestCase not implemented")
}
func (UnimplementedRunnerServer) BatchRun(Runner_BatchRunServer) error {
	return status.Errorf(codes.Unimplemented, "method BatchRun not implemented")
}
func (UnimplementedRunnerServer) GetTestCase(context.Context, *TestCaseIdentity) (*TestCase, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestCase not implemented")
}
func (UnimplementedRunnerServer) CreateTestCase(context.Context, *TestCaseWithSuite) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTestCase not implemented")
}
func (UnimplementedRunnerServer) UpdateTestCase(context.Context, *TestCaseWithSuite) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTestCase not implemented")
}
func (UnimplementedRunnerServer) DeleteTestCase(context.Context, *TestCaseIdentity) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTestCase not implemented")
}
func (UnimplementedRunnerServer) DuplicateTestCase(context.Context, *TestCaseDuplicate) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DuplicateTestCase not implemented")
}
func (UnimplementedRunnerServer) RenameTestCase(context.Context, *TestCaseDuplicate) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenameTestCase not implemented")
}
func (UnimplementedRunnerServer) GetSuggestedAPIs(context.Context, *TestSuiteIdentity) (*TestCases, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSuggestedAPIs not implemented")
}
func (UnimplementedRunnerServer) GetHistorySuites(context.Context, *Empty) (*HistorySuites, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHistorySuites not implemented")
}
func (UnimplementedRunnerServer) GetHistoryTestCaseWithResult(context.Context, *HistoryTestCase) (*HistoryTestResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHistoryTestCaseWithResult not implemented")
}
func (UnimplementedRunnerServer) GetHistoryTestCase(context.Context, *HistoryTestCase) (*HistoryTestCase, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHistoryTestCase not implemented")
}
func (UnimplementedRunnerServer) DeleteHistoryTestCase(context.Context, *HistoryTestCase) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteHistoryTestCase not implemented")
}
func (UnimplementedRunnerServer) DeleteAllHistoryTestCase(context.Context, *HistoryTestCase) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAllHistoryTestCase not implemented")
}
func (UnimplementedRunnerServer) GetTestCaseAllHistory(context.Context, *TestCase) (*HistoryTestCases, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestCaseAllHistory not implemented")
}
func (UnimplementedRunnerServer) ListCodeGenerator(context.Context, *Empty) (*SimpleList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCodeGenerator not implemented")
}
func (UnimplementedRunnerServer) GenerateCode(context.Context, *CodeGenerateRequest) (*CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateCode not implemented")
}
func (UnimplementedRunnerServer) HistoryGenerateCode(context.Context, *CodeGenerateRequest) (*CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HistoryGenerateCode not implemented")
}
func (UnimplementedRunnerServer) ListConverter(context.Context, *Empty) (*SimpleList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListConverter not implemented")
}
func (UnimplementedRunnerServer) ConvertTestSuite(context.Context, *CodeGenerateRequest) (*CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConvertTestSuite not implemented")
}
func (UnimplementedRunnerServer) PopularHeaders(context.Context, *Empty) (*Pairs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PopularHeaders not implemented")
}
func (UnimplementedRunnerServer) FunctionsQuery(context.Context, *SimpleQuery) (*Pairs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FunctionsQuery not implemented")
}
func (UnimplementedRunnerServer) FunctionsQueryStream(Runner_FunctionsQueryStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method FunctionsQueryStream not implemented")
}
func (UnimplementedRunnerServer) GetVersion(context.Context, *Empty) (*Version, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVersion not implemented")
}
func (UnimplementedRunnerServer) Sample(context.Context, *Empty) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sample not implemented")
}
func (UnimplementedRunnerServer) DownloadResponseFile(context.Context, *TestCase) (*FileData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DownloadResponseFile not implemented")
}
func (UnimplementedRunnerServer) GetStoreKinds(context.Context, *Empty) (*StoreKinds, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStoreKinds not implemented")
}
func (UnimplementedRunnerServer) GetStores(context.Context, *Empty) (*Stores, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStores not implemented")
}
func (UnimplementedRunnerServer) CreateStore(context.Context, *Store) (*Store, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateStore not implemented")
}
func (UnimplementedRunnerServer) UpdateStore(context.Context, *Store) (*Store, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateStore not implemented")
}
func (UnimplementedRunnerServer) DeleteStore(context.Context, *Store) (*Store, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteStore not implemented")
}
func (UnimplementedRunnerServer) VerifyStore(context.Context, *SimpleQuery) (*ExtensionStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyStore not implemented")
}
func (UnimplementedRunnerServer) GetSecrets(context.Context, *Empty) (*Secrets, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSecrets not implemented")
}
func (UnimplementedRunnerServer) CreateSecret(context.Context, *Secret) (*CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSecret not implemented")
}
func (UnimplementedRunnerServer) DeleteSecret(context.Context, *Secret) (*CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSecret not implemented")
}
func (UnimplementedRunnerServer) UpdateSecret(context.Context, *Secret) (*CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSecret not implemented")
}
func (UnimplementedRunnerServer) PProf(context.Context, *PProfRequest) (*PProfData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PProf not implemented")
}
func (UnimplementedRunnerServer) mustEmbedUnimplementedRunnerServer() {}

// UnsafeRunnerServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to RunnerServer will
// result in compilation errors.
type UnsafeRunnerServer interface {
	mustEmbedUnimplementedRunnerServer()
}

func RegisterRunnerServer(s grpc.ServiceRegistrar, srv RunnerServer) {
	s.RegisterService(&Runner_ServiceDesc, srv)
}

func _Runner_Run_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestTask)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).Run(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/Run",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).Run(ctx, req.(*TestTask))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_RunTestSuite_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RunnerServer).RunTestSuite(&runnerRunTestSuiteServer{stream})
}

type Runner_RunTestSuiteServer interface {
	Send(*TestResult) error
	Recv() (*TestSuiteIdentity, error)
	grpc.ServerStream
}

type runnerRunTestSuiteServer struct {
	grpc.ServerStream
}

func (x *runnerRunTestSuiteServer) Send(m *TestResult) error {
	return x.ServerStream.SendMsg(m)
}

func (x *runnerRunTestSuiteServer) Recv() (*TestSuiteIdentity, error) {
	m := new(TestSuiteIdentity)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Runner_GetSuites_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetSuites(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetSuites",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetSuites(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_CreateTestSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).CreateTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/CreateTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).CreateTestSuite(ctx, req.(*TestSuiteIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_ImportTestSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteSource)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).ImportTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/ImportTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).ImportTestSuite(ctx, req.(*TestSuiteSource))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetTestSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetTestSuite(ctx, req.(*TestSuiteIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_UpdateTestSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuite)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).UpdateTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/UpdateTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).UpdateTestSuite(ctx, req.(*TestSuite))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DeleteTestSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DeleteTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DeleteTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DeleteTestSuite(ctx, req.(*TestSuiteIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DuplicateTestSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteDuplicate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DuplicateTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DuplicateTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DuplicateTestSuite(ctx, req.(*TestSuiteDuplicate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_RenameTestSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteDuplicate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).RenameTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/RenameTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).RenameTestSuite(ctx, req.(*TestSuiteDuplicate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetTestSuiteYaml_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetTestSuiteYaml(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetTestSuiteYaml",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetTestSuiteYaml(ctx, req.(*TestSuiteIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_ListTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).ListTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/ListTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).ListTestCase(ctx, req.(*TestSuiteIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_RunTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCaseIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).RunTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/RunTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).RunTestCase(ctx, req.(*TestCaseIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_BatchRun_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RunnerServer).BatchRun(&runnerBatchRunServer{stream})
}

type Runner_BatchRunServer interface {
	Send(*TestResult) error
	Recv() (*BatchTestTask, error)
	grpc.ServerStream
}

type runnerBatchRunServer struct {
	grpc.ServerStream
}

func (x *runnerBatchRunServer) Send(m *TestResult) error {
	return x.ServerStream.SendMsg(m)
}

func (x *runnerBatchRunServer) Recv() (*BatchTestTask, error) {
	m := new(BatchTestTask)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Runner_GetTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCaseIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetTestCase(ctx, req.(*TestCaseIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_CreateTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCaseWithSuite)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).CreateTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/CreateTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).CreateTestCase(ctx, req.(*TestCaseWithSuite))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_UpdateTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCaseWithSuite)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).UpdateTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/UpdateTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).UpdateTestCase(ctx, req.(*TestCaseWithSuite))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DeleteTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCaseIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DeleteTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DeleteTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DeleteTestCase(ctx, req.(*TestCaseIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DuplicateTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCaseDuplicate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DuplicateTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DuplicateTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DuplicateTestCase(ctx, req.(*TestCaseDuplicate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_RenameTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCaseDuplicate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).RenameTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/RenameTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).RenameTestCase(ctx, req.(*TestCaseDuplicate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetSuggestedAPIs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetSuggestedAPIs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetSuggestedAPIs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetSuggestedAPIs(ctx, req.(*TestSuiteIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetHistorySuites_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetHistorySuites(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetHistorySuites",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetHistorySuites(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetHistoryTestCaseWithResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HistoryTestCase)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetHistoryTestCaseWithResult(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetHistoryTestCaseWithResult",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetHistoryTestCaseWithResult(ctx, req.(*HistoryTestCase))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetHistoryTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HistoryTestCase)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetHistoryTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetHistoryTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetHistoryTestCase(ctx, req.(*HistoryTestCase))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DeleteHistoryTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HistoryTestCase)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DeleteHistoryTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DeleteHistoryTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DeleteHistoryTestCase(ctx, req.(*HistoryTestCase))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DeleteAllHistoryTestCase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HistoryTestCase)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DeleteAllHistoryTestCase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DeleteAllHistoryTestCase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DeleteAllHistoryTestCase(ctx, req.(*HistoryTestCase))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetTestCaseAllHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCase)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetTestCaseAllHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetTestCaseAllHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetTestCaseAllHistory(ctx, req.(*TestCase))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_ListCodeGenerator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).ListCodeGenerator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/ListCodeGenerator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).ListCodeGenerator(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GenerateCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CodeGenerateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GenerateCode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GenerateCode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GenerateCode(ctx, req.(*CodeGenerateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_HistoryGenerateCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CodeGenerateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).HistoryGenerateCode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/HistoryGenerateCode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).HistoryGenerateCode(ctx, req.(*CodeGenerateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_ListConverter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).ListConverter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/ListConverter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).ListConverter(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_ConvertTestSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CodeGenerateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).ConvertTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/ConvertTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).ConvertTestSuite(ctx, req.(*CodeGenerateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_PopularHeaders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).PopularHeaders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/PopularHeaders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).PopularHeaders(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_FunctionsQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SimpleQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).FunctionsQuery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/FunctionsQuery",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).FunctionsQuery(ctx, req.(*SimpleQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_FunctionsQueryStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RunnerServer).FunctionsQueryStream(&runnerFunctionsQueryStreamServer{stream})
}

type Runner_FunctionsQueryStreamServer interface {
	Send(*Pairs) error
	Recv() (*SimpleQuery, error)
	grpc.ServerStream
}

type runnerFunctionsQueryStreamServer struct {
	grpc.ServerStream
}

func (x *runnerFunctionsQueryStreamServer) Send(m *Pairs) error {
	return x.ServerStream.SendMsg(m)
}

func (x *runnerFunctionsQueryStreamServer) Recv() (*SimpleQuery, error) {
	m := new(SimpleQuery)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Runner_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetVersion(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_Sample_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).Sample(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/Sample",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).Sample(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DownloadResponseFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestCase)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DownloadResponseFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DownloadResponseFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DownloadResponseFile(ctx, req.(*TestCase))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetStoreKinds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetStoreKinds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetStoreKinds",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetStoreKinds(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetStores_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetStores(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetStores",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetStores(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_CreateStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Store)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).CreateStore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/CreateStore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).CreateStore(ctx, req.(*Store))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_UpdateStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Store)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).UpdateStore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/UpdateStore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).UpdateStore(ctx, req.(*Store))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DeleteStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Store)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DeleteStore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DeleteStore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DeleteStore(ctx, req.(*Store))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_VerifyStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SimpleQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).VerifyStore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/VerifyStore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).VerifyStore(ctx, req.(*SimpleQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_GetSecrets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).GetSecrets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/GetSecrets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).GetSecrets(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_CreateSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Secret)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).CreateSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/CreateSecret",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).CreateSecret(ctx, req.(*Secret))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_DeleteSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Secret)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).DeleteSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/DeleteSecret",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).DeleteSecret(ctx, req.(*Secret))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_UpdateSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Secret)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).UpdateSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/UpdateSecret",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).UpdateSecret(ctx, req.(*Secret))
	}
	return interceptor(ctx, in, info, handler)
}

func _Runner_PProf_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PProfRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerServer).PProf(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Runner/PProf",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerServer).PProf(ctx, req.(*PProfRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Runner_ServiceDesc is the grpc.ServiceDesc for Runner service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Runner_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "server.Runner",
	HandlerType: (*RunnerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Run",
			Handler:    _Runner_Run_Handler,
		},
		{
			MethodName: "GetSuites",
			Handler:    _Runner_GetSuites_Handler,
		},
		{
			MethodName: "CreateTestSuite",
			Handler:    _Runner_CreateTestSuite_Handler,
		},
		{
			MethodName: "ImportTestSuite",
			Handler:    _Runner_ImportTestSuite_Handler,
		},
		{
			MethodName: "GetTestSuite",
			Handler:    _Runner_GetTestSuite_Handler,
		},
		{
			MethodName: "UpdateTestSuite",
			Handler:    _Runner_UpdateTestSuite_Handler,
		},
		{
			MethodName: "DeleteTestSuite",
			Handler:    _Runner_DeleteTestSuite_Handler,
		},
		{
			MethodName: "DuplicateTestSuite",
			Handler:    _Runner_DuplicateTestSuite_Handler,
		},
		{
			MethodName: "RenameTestSuite",
			Handler:    _Runner_RenameTestSuite_Handler,
		},
		{
			MethodName: "GetTestSuiteYaml",
			Handler:    _Runner_GetTestSuiteYaml_Handler,
		},
		{
			MethodName: "ListTestCase",
			Handler:    _Runner_ListTestCase_Handler,
		},
		{
			MethodName: "RunTestCase",
			Handler:    _Runner_RunTestCase_Handler,
		},
		{
			MethodName: "GetTestCase",
			Handler:    _Runner_GetTestCase_Handler,
		},
		{
			MethodName: "CreateTestCase",
			Handler:    _Runner_CreateTestCase_Handler,
		},
		{
			MethodName: "UpdateTestCase",
			Handler:    _Runner_UpdateTestCase_Handler,
		},
		{
			MethodName: "DeleteTestCase",
			Handler:    _Runner_DeleteTestCase_Handler,
		},
		{
			MethodName: "DuplicateTestCase",
			Handler:    _Runner_DuplicateTestCase_Handler,
		},
		{
			MethodName: "RenameTestCase",
			Handler:    _Runner_RenameTestCase_Handler,
		},
		{
			MethodName: "GetSuggestedAPIs",
			Handler:    _Runner_GetSuggestedAPIs_Handler,
		},
		{
			MethodName: "GetHistorySuites",
			Handler:    _Runner_GetHistorySuites_Handler,
		},
		{
			MethodName: "GetHistoryTestCaseWithResult",
			Handler:    _Runner_GetHistoryTestCaseWithResult_Handler,
		},
		{
			MethodName: "GetHistoryTestCase",
			Handler:    _Runner_GetHistoryTestCase_Handler,
		},
		{
			MethodName: "DeleteHistoryTestCase",
			Handler:    _Runner_DeleteHistoryTestCase_Handler,
		},
		{
			MethodName: "DeleteAllHistoryTestCase",
			Handler:    _Runner_DeleteAllHistoryTestCase_Handler,
		},
		{
			MethodName: "GetTestCaseAllHistory",
			Handler:    _Runner_GetTestCaseAllHistory_Handler,
		},
		{
			MethodName: "ListCodeGenerator",
			Handler:    _Runner_ListCodeGenerator_Handler,
		},
		{
			MethodName: "GenerateCode",
			Handler:    _Runner_GenerateCode_Handler,
		},
		{
			MethodName: "HistoryGenerateCode",
			Handler:    _Runner_HistoryGenerateCode_Handler,
		},
		{
			MethodName: "ListConverter",
			Handler:    _Runner_ListConverter_Handler,
		},
		{
			MethodName: "ConvertTestSuite",
			Handler:    _Runner_ConvertTestSuite_Handler,
		},
		{
			MethodName: "PopularHeaders",
			Handler:    _Runner_PopularHeaders_Handler,
		},
		{
			MethodName: "FunctionsQuery",
			Handler:    _Runner_FunctionsQuery_Handler,
		},
		{
			MethodName: "GetVersion",
			Handler:    _Runner_GetVersion_Handler,
		},
		{
			MethodName: "Sample",
			Handler:    _Runner_Sample_Handler,
		},
		{
			MethodName: "DownloadResponseFile",
			Handler:    _Runner_DownloadResponseFile_Handler,
		},
		{
			MethodName: "GetStoreKinds",
			Handler:    _Runner_GetStoreKinds_Handler,
		},
		{
			MethodName: "GetStores",
			Handler:    _Runner_GetStores_Handler,
		},
		{
			MethodName: "CreateStore",
			Handler:    _Runner_CreateStore_Handler,
		},
		{
			MethodName: "UpdateStore",
			Handler:    _Runner_UpdateStore_Handler,
		},
		{
			MethodName: "DeleteStore",
			Handler:    _Runner_DeleteStore_Handler,
		},
		{
			MethodName: "VerifyStore",
			Handler:    _Runner_VerifyStore_Handler,
		},
		{
			MethodName: "GetSecrets",
			Handler:    _Runner_GetSecrets_Handler,
		},
		{
			MethodName: "CreateSecret",
			Handler:    _Runner_CreateSecret_Handler,
		},
		{
			MethodName: "DeleteSecret",
			Handler:    _Runner_DeleteSecret_Handler,
		},
		{
			MethodName: "UpdateSecret",
			Handler:    _Runner_UpdateSecret_Handler,
		},
		{
			MethodName: "PProf",
			Handler:    _Runner_PProf_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RunTestSuite",
			Handler:       _Runner_RunTestSuite_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "BatchRun",
			Handler:       _Runner_BatchRun_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "FunctionsQueryStream",
			Handler:       _Runner_FunctionsQueryStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "pkg/server/server.proto",
}

// RunnerExtensionClient is the client API for RunnerExtension service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type RunnerExtensionClient interface {
	Run(ctx context.Context, in *TestSuiteWithCase, opts ...grpc.CallOption) (*CommonResult, error)
}

type runnerExtensionClient struct {
	cc grpc.ClientConnInterface
}

func NewRunnerExtensionClient(cc grpc.ClientConnInterface) RunnerExtensionClient {
	return &runnerExtensionClient{cc}
}

func (c *runnerExtensionClient) Run(ctx context.Context, in *TestSuiteWithCase, opts ...grpc.CallOption) (*CommonResult, error) {
	out := new(CommonResult)
	err := c.cc.Invoke(ctx, "/server.RunnerExtension/Run", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RunnerExtensionServer is the server API for RunnerExtension service.
// All implementations must embed UnimplementedRunnerExtensionServer
// for forward compatibility
type RunnerExtensionServer interface {
	Run(context.Context, *TestSuiteWithCase) (*CommonResult, error)
	mustEmbedUnimplementedRunnerExtensionServer()
}

// UnimplementedRunnerExtensionServer must be embedded to have forward compatible implementations.
type UnimplementedRunnerExtensionServer struct {
}

func (UnimplementedRunnerExtensionServer) Run(context.Context, *TestSuiteWithCase) (*CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Run not implemented")
}
func (UnimplementedRunnerExtensionServer) mustEmbedUnimplementedRunnerExtensionServer() {}

// UnsafeRunnerExtensionServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to RunnerExtensionServer will
// result in compilation errors.
type UnsafeRunnerExtensionServer interface {
	mustEmbedUnimplementedRunnerExtensionServer()
}

func RegisterRunnerExtensionServer(s grpc.ServiceRegistrar, srv RunnerExtensionServer) {
	s.RegisterService(&RunnerExtension_ServiceDesc, srv)
}

func _RunnerExtension_Run_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestSuiteWithCase)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerExtensionServer).Run(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.RunnerExtension/Run",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerExtensionServer).Run(ctx, req.(*TestSuiteWithCase))
	}
	return interceptor(ctx, in, info, handler)
}

// RunnerExtension_ServiceDesc is the grpc.ServiceDesc for RunnerExtension service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RunnerExtension_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "server.RunnerExtension",
	HandlerType: (*RunnerExtensionServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Run",
			Handler:    _RunnerExtension_Run_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/server/server.proto",
}

// MockClient is the client API for Mock service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type MockClient interface {
	Reload(ctx context.Context, in *MockConfig, opts ...grpc.CallOption) (*Empty, error)
	GetConfig(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*MockConfig, error)
}

type mockClient struct {
	cc grpc.ClientConnInterface
}

func NewMockClient(cc grpc.ClientConnInterface) MockClient {
	return &mockClient{cc}
}

func (c *mockClient) Reload(ctx context.Context, in *MockConfig, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/server.Mock/Reload", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mockClient) GetConfig(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*MockConfig, error) {
	out := new(MockConfig)
	err := c.cc.Invoke(ctx, "/server.Mock/GetConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MockServer is the server API for Mock service.
// All implementations must embed UnimplementedMockServer
// for forward compatibility
type MockServer interface {
	Reload(context.Context, *MockConfig) (*Empty, error)
	GetConfig(context.Context, *Empty) (*MockConfig, error)
	mustEmbedUnimplementedMockServer()
}

// UnimplementedMockServer must be embedded to have forward compatible implementations.
type UnimplementedMockServer struct {
}

func (UnimplementedMockServer) Reload(context.Context, *MockConfig) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Reload not implemented")
}
func (UnimplementedMockServer) GetConfig(context.Context, *Empty) (*MockConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConfig not implemented")
}
func (UnimplementedMockServer) mustEmbedUnimplementedMockServer() {}

// UnsafeMockServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to MockServer will
// result in compilation errors.
type UnsafeMockServer interface {
	mustEmbedUnimplementedMockServer()
}

func RegisterMockServer(s grpc.ServiceRegistrar, srv MockServer) {
	s.RegisterService(&Mock_ServiceDesc, srv)
}

func _Mock_Reload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MockConfig)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MockServer).Reload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Mock/Reload",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MockServer).Reload(ctx, req.(*MockConfig))
	}
	return interceptor(ctx, in, info, handler)
}

func _Mock_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MockServer).GetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.Mock/GetConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MockServer).GetConfig(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

// Mock_ServiceDesc is the grpc.ServiceDesc for Mock service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Mock_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "server.Mock",
	HandlerType: (*MockServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Reload",
			Handler:    _Mock_Reload_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _Mock_GetConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/server/server.proto",
}

// DataServerClient is the client API for DataServer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DataServerClient interface {
	Query(ctx context.Context, in *DataQuery, opts ...grpc.CallOption) (*DataQueryResult, error)
}

type dataServerClient struct {
	cc grpc.ClientConnInterface
}

func NewDataServerClient(cc grpc.ClientConnInterface) DataServerClient {
	return &dataServerClient{cc}
}

func (c *dataServerClient) Query(ctx context.Context, in *DataQuery, opts ...grpc.CallOption) (*DataQueryResult, error) {
	out := new(DataQueryResult)
	err := c.cc.Invoke(ctx, "/server.DataServer/Query", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DataServerServer is the server API for DataServer service.
// All implementations must embed UnimplementedDataServerServer
// for forward compatibility
type DataServerServer interface {
	Query(context.Context, *DataQuery) (*DataQueryResult, error)
	mustEmbedUnimplementedDataServerServer()
}

// UnimplementedDataServerServer must be embedded to have forward compatible implementations.
type UnimplementedDataServerServer struct {
}

func (UnimplementedDataServerServer) Query(context.Context, *DataQuery) (*DataQueryResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Query not implemented")
}
func (UnimplementedDataServerServer) mustEmbedUnimplementedDataServerServer() {}

// UnsafeDataServerServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DataServerServer will
// result in compilation errors.
type UnsafeDataServerServer interface {
	mustEmbedUnimplementedDataServerServer()
}

func RegisterDataServerServer(s grpc.ServiceRegistrar, srv DataServerServer) {
	s.RegisterService(&DataServer_ServiceDesc, srv)
}

func _DataServer_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DataQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataServerServer).Query(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/server.DataServer/Query",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataServerServer).Query(ctx, req.(*DataQuery))
	}
	return interceptor(ctx, in, info, handler)
}

// DataServer_ServiceDesc is the grpc.ServiceDesc for DataServer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DataServer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "server.DataServer",
	HandlerType: (*DataServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Query",
			Handler:    _DataServer_Query_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/server/server.proto",
}