api-testing/pkg/testing/remote/loader_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/testing/remote/loader.proto

package remote

import (
	context "context"
	server "github.com/linuxsuren/api-testing/pkg/server"
	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

// LoaderClient is the client API for Loader 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 LoaderClient interface {
	ListTestSuite(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*TestSuites, error)
	CreateTestSuite(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*server.Empty, error)
	GetTestSuite(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*TestSuite, error)
	UpdateTestSuite(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*TestSuite, error)
	DeleteTestSuite(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*server.Empty, error)
	RenameTestSuite(ctx context.Context, in *server.TestSuiteDuplicate, opts ...grpc.CallOption) (*server.HelloReply, error)
	ListTestCases(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*server.TestCases, error)
	CreateTestCase(ctx context.Context, in *server.TestCase, opts ...grpc.CallOption) (*server.Empty, error)
	GetTestCase(ctx context.Context, in *server.TestCase, opts ...grpc.CallOption) (*server.TestCase, error)
	UpdateTestCase(ctx context.Context, in *server.TestCase, opts ...grpc.CallOption) (*server.TestCase, error)
	DeleteTestCase(ctx context.Context, in *server.TestCase, opts ...grpc.CallOption) (*server.Empty, error)
	RenameTestCase(ctx context.Context, in *server.TestCaseDuplicate, opts ...grpc.CallOption) (*server.HelloReply, error)
	ListHistoryTestSuite(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*HistoryTestSuites, error)
	CreateTestCaseHistory(ctx context.Context, in *server.HistoryTestResult, opts ...grpc.CallOption) (*server.Empty, error)
	GetHistoryTestCaseWithResult(ctx context.Context, in *server.HistoryTestCase, opts ...grpc.CallOption) (*server.HistoryTestResult, error)
	GetHistoryTestCase(ctx context.Context, in *server.HistoryTestCase, opts ...grpc.CallOption) (*server.HistoryTestCase, error)
	DeleteHistoryTestCase(ctx context.Context, in *server.HistoryTestCase, opts ...grpc.CallOption) (*server.Empty, error)
	DeleteAllHistoryTestCase(ctx context.Context, in *server.HistoryTestCase, opts ...grpc.CallOption) (*server.Empty, error)
	GetTestCaseAllHistory(ctx context.Context, in *server.TestCase, opts ...grpc.CallOption) (*server.HistoryTestCases, error)
	GetVersion(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*server.Version, error)
	Verify(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*server.ExtensionStatus, error)
	PProf(ctx context.Context, in *server.PProfRequest, opts ...grpc.CallOption) (*server.PProfData, error)
	Query(ctx context.Context, in *server.DataQuery, opts ...grpc.CallOption) (*server.DataQueryResult, error)
}

type loaderClient struct {
	cc grpc.ClientConnInterface
}

func NewLoaderClient(cc grpc.ClientConnInterface) LoaderClient {
	return &loaderClient{cc}
}

func (c *loaderClient) ListTestSuite(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*TestSuites, error) {
	out := new(TestSuites)
	err := c.cc.Invoke(ctx, "/remote.Loader/ListTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loaderClient) CreateTestSuite(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*server.Empty, error) {
	out := new(server.Empty)
	err := c.cc.Invoke(ctx, "/remote.Loader/CreateTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

func (c *loaderClient) DeleteTestSuite(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*server.Empty, error) {
	out := new(server.Empty)
	err := c.cc.Invoke(ctx, "/remote.Loader/DeleteTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *loaderClient) ListTestCases(ctx context.Context, in *TestSuite, opts ...grpc.CallOption) (*server.TestCases, error) {
	out := new(server.TestCases)
	err := c.cc.Invoke(ctx, "/remote.Loader/ListTestCases", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loaderClient) CreateTestCase(ctx context.Context, in *server.TestCase, opts ...grpc.CallOption) (*server.Empty, error) {
	out := new(server.Empty)
	err := c.cc.Invoke(ctx, "/remote.Loader/CreateTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

func (c *loaderClient) DeleteTestCase(ctx context.Context, in *server.TestCase, opts ...grpc.CallOption) (*server.Empty, error) {
	out := new(server.Empty)
	err := c.cc.Invoke(ctx, "/remote.Loader/DeleteTestCase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *loaderClient) ListHistoryTestSuite(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*HistoryTestSuites, error) {
	out := new(HistoryTestSuites)
	err := c.cc.Invoke(ctx, "/remote.Loader/ListHistoryTestSuite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loaderClient) CreateTestCaseHistory(ctx context.Context, in *server.HistoryTestResult, opts ...grpc.CallOption) (*server.Empty, error) {
	out := new(server.Empty)
	err := c.cc.Invoke(ctx, "/remote.Loader/CreateTestCaseHistory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

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

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

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

func (c *loaderClient) Verify(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*server.ExtensionStatus, error) {
	out := new(server.ExtensionStatus)
	err := c.cc.Invoke(ctx, "/remote.Loader/Verify", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

// LoaderServer is the server API for Loader service.
// All implementations must embed UnimplementedLoaderServer
// for forward compatibility
type LoaderServer interface {
	ListTestSuite(context.Context, *server.Empty) (*TestSuites, error)
	CreateTestSuite(context.Context, *TestSuite) (*server.Empty, error)
	GetTestSuite(context.Context, *TestSuite) (*TestSuite, error)
	UpdateTestSuite(context.Context, *TestSuite) (*TestSuite, error)
	DeleteTestSuite(context.Context, *TestSuite) (*server.Empty, error)
	RenameTestSuite(context.Context, *server.TestSuiteDuplicate) (*server.HelloReply, error)
	ListTestCases(context.Context, *TestSuite) (*server.TestCases, error)
	CreateTestCase(context.Context, *server.TestCase) (*server.Empty, error)
	GetTestCase(context.Context, *server.TestCase) (*server.TestCase, error)
	UpdateTestCase(context.Context, *server.TestCase) (*server.TestCase, error)
	DeleteTestCase(context.Context, *server.TestCase) (*server.Empty, error)
	RenameTestCase(context.Context, *server.TestCaseDuplicate) (*server.HelloReply, error)
	ListHistoryTestSuite(context.Context, *server.Empty) (*HistoryTestSuites, error)
	CreateTestCaseHistory(context.Context, *server.HistoryTestResult) (*server.Empty, error)
	GetHistoryTestCaseWithResult(context.Context, *server.HistoryTestCase) (*server.HistoryTestResult, error)
	GetHistoryTestCase(context.Context, *server.HistoryTestCase) (*server.HistoryTestCase, error)
	DeleteHistoryTestCase(context.Context, *server.HistoryTestCase) (*server.Empty, error)
	DeleteAllHistoryTestCase(context.Context, *server.HistoryTestCase) (*server.Empty, error)
	GetTestCaseAllHistory(context.Context, *server.TestCase) (*server.HistoryTestCases, error)
	GetVersion(context.Context, *server.Empty) (*server.Version, error)
	Verify(context.Context, *server.Empty) (*server.ExtensionStatus, error)
	PProf(context.Context, *server.PProfRequest) (*server.PProfData, error)
	Query(context.Context, *server.DataQuery) (*server.DataQueryResult, error)
	mustEmbedUnimplementedLoaderServer()
}

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

func (UnimplementedLoaderServer) ListTestSuite(context.Context, *server.Empty) (*TestSuites, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTestSuite not implemented")
}
func (UnimplementedLoaderServer) CreateTestSuite(context.Context, *TestSuite) (*server.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTestSuite not implemented")
}
func (UnimplementedLoaderServer) GetTestSuite(context.Context, *TestSuite) (*TestSuite, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestSuite not implemented")
}
func (UnimplementedLoaderServer) UpdateTestSuite(context.Context, *TestSuite) (*TestSuite, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTestSuite not implemented")
}
func (UnimplementedLoaderServer) DeleteTestSuite(context.Context, *TestSuite) (*server.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTestSuite not implemented")
}
func (UnimplementedLoaderServer) RenameTestSuite(context.Context, *server.TestSuiteDuplicate) (*server.HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenameTestSuite not implemented")
}
func (UnimplementedLoaderServer) ListTestCases(context.Context, *TestSuite) (*server.TestCases, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTestCases not implemented")
}
func (UnimplementedLoaderServer) CreateTestCase(context.Context, *server.TestCase) (*server.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTestCase not implemented")
}
func (UnimplementedLoaderServer) GetTestCase(context.Context, *server.TestCase) (*server.TestCase, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestCase not implemented")
}
func (UnimplementedLoaderServer) UpdateTestCase(context.Context, *server.TestCase) (*server.TestCase, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTestCase not implemented")
}
func (UnimplementedLoaderServer) DeleteTestCase(context.Context, *server.TestCase) (*server.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTestCase not implemented")
}
func (UnimplementedLoaderServer) RenameTestCase(context.Context, *server.TestCaseDuplicate) (*server.HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenameTestCase not implemented")
}
func (UnimplementedLoaderServer) ListHistoryTestSuite(context.Context, *server.Empty) (*HistoryTestSuites, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListHistoryTestSuite not implemented")
}
func (UnimplementedLoaderServer) CreateTestCaseHistory(context.Context, *server.HistoryTestResult) (*server.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTestCaseHistory not implemented")
}
func (UnimplementedLoaderServer) GetHistoryTestCaseWithResult(context.Context, *server.HistoryTestCase) (*server.HistoryTestResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHistoryTestCaseWithResult not implemented")
}
func (UnimplementedLoaderServer) GetHistoryTestCase(context.Context, *server.HistoryTestCase) (*server.HistoryTestCase, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHistoryTestCase not implemented")
}
func (UnimplementedLoaderServer) DeleteHistoryTestCase(context.Context, *server.HistoryTestCase) (*server.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteHistoryTestCase not implemented")
}
func (UnimplementedLoaderServer) DeleteAllHistoryTestCase(context.Context, *server.HistoryTestCase) (*server.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAllHistoryTestCase not implemented")
}
func (UnimplementedLoaderServer) GetTestCaseAllHistory(context.Context, *server.TestCase) (*server.HistoryTestCases, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestCaseAllHistory not implemented")
}
func (UnimplementedLoaderServer) GetVersion(context.Context, *server.Empty) (*server.Version, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVersion not implemented")
}
func (UnimplementedLoaderServer) Verify(context.Context, *server.Empty) (*server.ExtensionStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Verify not implemented")
}
func (UnimplementedLoaderServer) PProf(context.Context, *server.PProfRequest) (*server.PProfData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PProf not implemented")
}
func (UnimplementedLoaderServer) Query(context.Context, *server.DataQuery) (*server.DataQueryResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Query not implemented")
}
func (UnimplementedLoaderServer) mustEmbedUnimplementedLoaderServer() {}

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

func RegisterLoaderServer(s grpc.ServiceRegistrar, srv LoaderServer) {
	s.RegisterService(&Loader_ServiceDesc, srv)
}

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

func _Loader_CreateTestSuite_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.(LoaderServer).CreateTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.Loader/CreateTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoaderServer).CreateTestSuite(ctx, req.(*TestSuite))
	}
	return interceptor(ctx, in, info, handler)
}

func _Loader_GetTestSuite_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.(LoaderServer).GetTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.Loader/GetTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoaderServer).GetTestSuite(ctx, req.(*TestSuite))
	}
	return interceptor(ctx, in, info, handler)
}

func _Loader_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.(LoaderServer).UpdateTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.Loader/UpdateTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoaderServer).UpdateTestSuite(ctx, req.(*TestSuite))
	}
	return interceptor(ctx, in, info, handler)
}

func _Loader_DeleteTestSuite_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.(LoaderServer).DeleteTestSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.Loader/DeleteTestSuite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoaderServer).DeleteTestSuite(ctx, req.(*TestSuite))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _Loader_ListTestCases_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.(LoaderServer).ListTestCases(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.Loader/ListTestCases",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoaderServer).ListTestCases(ctx, req.(*TestSuite))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

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

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

func _Loader_CreateTestCaseHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(server.HistoryTestResult)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoaderServer).CreateTestCaseHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.Loader/CreateTestCaseHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoaderServer).CreateTestCaseHistory(ctx, req.(*server.HistoryTestResult))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

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

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

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

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

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

// Loader_ServiceDesc is the grpc.ServiceDesc for Loader service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Loader_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "remote.Loader",
	HandlerType: (*LoaderServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListTestSuite",
			Handler:    _Loader_ListTestSuite_Handler,
		},
		{
			MethodName: "CreateTestSuite",
			Handler:    _Loader_CreateTestSuite_Handler,
		},
		{
			MethodName: "GetTestSuite",
			Handler:    _Loader_GetTestSuite_Handler,
		},
		{
			MethodName: "UpdateTestSuite",
			Handler:    _Loader_UpdateTestSuite_Handler,
		},
		{
			MethodName: "DeleteTestSuite",
			Handler:    _Loader_DeleteTestSuite_Handler,
		},
		{
			MethodName: "RenameTestSuite",
			Handler:    _Loader_RenameTestSuite_Handler,
		},
		{
			MethodName: "ListTestCases",
			Handler:    _Loader_ListTestCases_Handler,
		},
		{
			MethodName: "CreateTestCase",
			Handler:    _Loader_CreateTestCase_Handler,
		},
		{
			MethodName: "GetTestCase",
			Handler:    _Loader_GetTestCase_Handler,
		},
		{
			MethodName: "UpdateTestCase",
			Handler:    _Loader_UpdateTestCase_Handler,
		},
		{
			MethodName: "DeleteTestCase",
			Handler:    _Loader_DeleteTestCase_Handler,
		},
		{
			MethodName: "RenameTestCase",
			Handler:    _Loader_RenameTestCase_Handler,
		},
		{
			MethodName: "ListHistoryTestSuite",
			Handler:    _Loader_ListHistoryTestSuite_Handler,
		},
		{
			MethodName: "CreateTestCaseHistory",
			Handler:    _Loader_CreateTestCaseHistory_Handler,
		},
		{
			MethodName: "GetHistoryTestCaseWithResult",
			Handler:    _Loader_GetHistoryTestCaseWithResult_Handler,
		},
		{
			MethodName: "GetHistoryTestCase",
			Handler:    _Loader_GetHistoryTestCase_Handler,
		},
		{
			MethodName: "DeleteHistoryTestCase",
			Handler:    _Loader_DeleteHistoryTestCase_Handler,
		},
		{
			MethodName: "DeleteAllHistoryTestCase",
			Handler:    _Loader_DeleteAllHistoryTestCase_Handler,
		},
		{
			MethodName: "GetTestCaseAllHistory",
			Handler:    _Loader_GetTestCaseAllHistory_Handler,
		},
		{
			MethodName: "GetVersion",
			Handler:    _Loader_GetVersion_Handler,
		},
		{
			MethodName: "Verify",
			Handler:    _Loader_Verify_Handler,
		},
		{
			MethodName: "PProf",
			Handler:    _Loader_PProf_Handler,
		},
		{
			MethodName: "Query",
			Handler:    _Loader_Query_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/testing/remote/loader.proto",
}

// SecretServiceClient is the client API for SecretService 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 SecretServiceClient interface {
	GetSecret(ctx context.Context, in *server.Secret, opts ...grpc.CallOption) (*server.Secret, error)
	GetSecrets(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*server.Secrets, error)
	CreateSecret(ctx context.Context, in *server.Secret, opts ...grpc.CallOption) (*server.CommonResult, error)
	DeleteSecret(ctx context.Context, in *server.Secret, opts ...grpc.CallOption) (*server.CommonResult, error)
	UpdateSecret(ctx context.Context, in *server.Secret, opts ...grpc.CallOption) (*server.CommonResult, error)
}

type secretServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSecretServiceClient(cc grpc.ClientConnInterface) SecretServiceClient {
	return &secretServiceClient{cc}
}

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

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

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

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

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

// SecretServiceServer is the server API for SecretService service.
// All implementations must embed UnimplementedSecretServiceServer
// for forward compatibility
type SecretServiceServer interface {
	GetSecret(context.Context, *server.Secret) (*server.Secret, error)
	GetSecrets(context.Context, *server.Empty) (*server.Secrets, error)
	CreateSecret(context.Context, *server.Secret) (*server.CommonResult, error)
	DeleteSecret(context.Context, *server.Secret) (*server.CommonResult, error)
	UpdateSecret(context.Context, *server.Secret) (*server.CommonResult, error)
	mustEmbedUnimplementedSecretServiceServer()
}

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

func (UnimplementedSecretServiceServer) GetSecret(context.Context, *server.Secret) (*server.Secret, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSecret not implemented")
}
func (UnimplementedSecretServiceServer) GetSecrets(context.Context, *server.Empty) (*server.Secrets, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSecrets not implemented")
}
func (UnimplementedSecretServiceServer) CreateSecret(context.Context, *server.Secret) (*server.CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSecret not implemented")
}
func (UnimplementedSecretServiceServer) DeleteSecret(context.Context, *server.Secret) (*server.CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSecret not implemented")
}
func (UnimplementedSecretServiceServer) UpdateSecret(context.Context, *server.Secret) (*server.CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSecret not implemented")
}
func (UnimplementedSecretServiceServer) mustEmbedUnimplementedSecretServiceServer() {}

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

func RegisterSecretServiceServer(s grpc.ServiceRegistrar, srv SecretServiceServer) {
	s.RegisterService(&SecretService_ServiceDesc, srv)
}

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

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

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

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

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

// SecretService_ServiceDesc is the grpc.ServiceDesc for SecretService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SecretService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "remote.SecretService",
	HandlerType: (*SecretServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetSecret",
			Handler:    _SecretService_GetSecret_Handler,
		},
		{
			MethodName: "GetSecrets",
			Handler:    _SecretService_GetSecrets_Handler,
		},
		{
			MethodName: "CreateSecret",
			Handler:    _SecretService_CreateSecret_Handler,
		},
		{
			MethodName: "DeleteSecret",
			Handler:    _SecretService_DeleteSecret_Handler,
		},
		{
			MethodName: "UpdateSecret",
			Handler:    _SecretService_UpdateSecret_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/testing/remote/loader.proto",
}

// ConfigServiceClient is the client API for ConfigService 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 ConfigServiceClient interface {
	GetConfigs(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*Configs, error)
	GetConfig(ctx context.Context, in *server.SimpleName, opts ...grpc.CallOption) (*Config, error)
	CreateConfig(ctx context.Context, in *Config, opts ...grpc.CallOption) (*server.CommonResult, error)
	UpdateConfig(ctx context.Context, in *Config, opts ...grpc.CallOption) (*server.CommonResult, error)
	DeleteConfig(ctx context.Context, in *server.SimpleName, opts ...grpc.CallOption) (*server.CommonResult, error)
}

type configServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewConfigServiceClient(cc grpc.ClientConnInterface) ConfigServiceClient {
	return &configServiceClient{cc}
}

func (c *configServiceClient) GetConfigs(ctx context.Context, in *server.Empty, opts ...grpc.CallOption) (*Configs, error) {
	out := new(Configs)
	err := c.cc.Invoke(ctx, "/remote.ConfigService/GetConfigs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configServiceClient) GetConfig(ctx context.Context, in *server.SimpleName, opts ...grpc.CallOption) (*Config, error) {
	out := new(Config)
	err := c.cc.Invoke(ctx, "/remote.ConfigService/GetConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configServiceClient) CreateConfig(ctx context.Context, in *Config, opts ...grpc.CallOption) (*server.CommonResult, error) {
	out := new(server.CommonResult)
	err := c.cc.Invoke(ctx, "/remote.ConfigService/CreateConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configServiceClient) UpdateConfig(ctx context.Context, in *Config, opts ...grpc.CallOption) (*server.CommonResult, error) {
	out := new(server.CommonResult)
	err := c.cc.Invoke(ctx, "/remote.ConfigService/UpdateConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configServiceClient) DeleteConfig(ctx context.Context, in *server.SimpleName, opts ...grpc.CallOption) (*server.CommonResult, error) {
	out := new(server.CommonResult)
	err := c.cc.Invoke(ctx, "/remote.ConfigService/DeleteConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ConfigServiceServer is the server API for ConfigService service.
// All implementations must embed UnimplementedConfigServiceServer
// for forward compatibility
type ConfigServiceServer interface {
	GetConfigs(context.Context, *server.Empty) (*Configs, error)
	GetConfig(context.Context, *server.SimpleName) (*Config, error)
	CreateConfig(context.Context, *Config) (*server.CommonResult, error)
	UpdateConfig(context.Context, *Config) (*server.CommonResult, error)
	DeleteConfig(context.Context, *server.SimpleName) (*server.CommonResult, error)
	mustEmbedUnimplementedConfigServiceServer()
}

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

func (UnimplementedConfigServiceServer) GetConfigs(context.Context, *server.Empty) (*Configs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConfigs not implemented")
}
func (UnimplementedConfigServiceServer) GetConfig(context.Context, *server.SimpleName) (*Config, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConfig not implemented")
}
func (UnimplementedConfigServiceServer) CreateConfig(context.Context, *Config) (*server.CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateConfig not implemented")
}
func (UnimplementedConfigServiceServer) UpdateConfig(context.Context, *Config) (*server.CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateConfig not implemented")
}
func (UnimplementedConfigServiceServer) DeleteConfig(context.Context, *server.SimpleName) (*server.CommonResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteConfig not implemented")
}
func (UnimplementedConfigServiceServer) mustEmbedUnimplementedConfigServiceServer() {}

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

func RegisterConfigServiceServer(s grpc.ServiceRegistrar, srv ConfigServiceServer) {
	s.RegisterService(&ConfigService_ServiceDesc, srv)
}

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

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

func _ConfigService_CreateConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Config)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigServiceServer).CreateConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.ConfigService/CreateConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigServiceServer).CreateConfig(ctx, req.(*Config))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigService_UpdateConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Config)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigServiceServer).UpdateConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.ConfigService/UpdateConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigServiceServer).UpdateConfig(ctx, req.(*Config))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigService_DeleteConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(server.SimpleName)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigServiceServer).DeleteConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/remote.ConfigService/DeleteConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigServiceServer).DeleteConfig(ctx, req.(*server.SimpleName))
	}
	return interceptor(ctx, in, info, handler)
}

// ConfigService_ServiceDesc is the grpc.ServiceDesc for ConfigService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ConfigService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "remote.ConfigService",
	HandlerType: (*ConfigServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetConfigs",
			Handler:    _ConfigService_GetConfigs_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _ConfigService_GetConfig_Handler,
		},
		{
			MethodName: "CreateConfig",
			Handler:    _ConfigService_CreateConfig_Handler,
		},
		{
			MethodName: "UpdateConfig",
			Handler:    _ConfigService_UpdateConfig_Handler,
		},
		{
			MethodName: "DeleteConfig",
			Handler:    _ConfigService_DeleteConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/testing/remote/loader.proto",
}