query-orchestration/api/grpc/spec/main_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             v3.12.4
// source: main.proto

package spec

import (
	context "context"
	empty "github.com/golang/protobuf/ptypes/empty"
	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.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	QueryService_List_FullMethodName   = "/queryorchestration.QueryService/List"
	QueryService_Get_FullMethodName    = "/queryorchestration.QueryService/Get"
	QueryService_Create_FullMethodName = "/queryorchestration.QueryService/Create"
	QueryService_Update_FullMethodName = "/queryorchestration.QueryService/Update"
	QueryService_Remove_FullMethodName = "/queryorchestration.QueryService/Remove"
	QueryService_Test_FullMethodName   = "/queryorchestration.QueryService/Test"
)

// QueryServiceClient is the client API for QueryService 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 QueryServiceClient interface {
	List(ctx context.Context, in *QueryFilter, opts ...grpc.CallOption) (*Queries, error)
	Get(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*Query, error)
	Create(ctx context.Context, in *QueryCreate, opts ...grpc.CallOption) (*IdMessage, error)
	Update(ctx context.Context, in *QueryUpdate, opts ...grpc.CallOption) (*empty.Empty, error)
	Remove(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*empty.Empty, error)
	Test(ctx context.Context, in *QueryTestRequest, opts ...grpc.CallOption) (*QueryTestResponse, error)
}

type queryServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewQueryServiceClient(cc grpc.ClientConnInterface) QueryServiceClient {
	return &queryServiceClient{cc}
}

func (c *queryServiceClient) List(ctx context.Context, in *QueryFilter, opts ...grpc.CallOption) (*Queries, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Queries)
	err := c.cc.Invoke(ctx, QueryService_List_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryServiceClient) Get(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*Query, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Query)
	err := c.cc.Invoke(ctx, QueryService_Get_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryServiceClient) Create(ctx context.Context, in *QueryCreate, opts ...grpc.CallOption) (*IdMessage, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IdMessage)
	err := c.cc.Invoke(ctx, QueryService_Create_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryServiceClient) Update(ctx context.Context, in *QueryUpdate, opts ...grpc.CallOption) (*empty.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, QueryService_Update_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryServiceClient) Remove(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*empty.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, QueryService_Remove_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryServiceClient) Test(ctx context.Context, in *QueryTestRequest, opts ...grpc.CallOption) (*QueryTestResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(QueryTestResponse)
	err := c.cc.Invoke(ctx, QueryService_Test_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServiceServer is the server API for QueryService service.
// All implementations must embed UnimplementedQueryServiceServer
// for forward compatibility.
type QueryServiceServer interface {
	List(context.Context, *QueryFilter) (*Queries, error)
	Get(context.Context, *IdMessage) (*Query, error)
	Create(context.Context, *QueryCreate) (*IdMessage, error)
	Update(context.Context, *QueryUpdate) (*empty.Empty, error)
	Remove(context.Context, *IdMessage) (*empty.Empty, error)
	Test(context.Context, *QueryTestRequest) (*QueryTestResponse, error)
	mustEmbedUnimplementedQueryServiceServer()
}

// UnimplementedQueryServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedQueryServiceServer struct{}

func (UnimplementedQueryServiceServer) List(context.Context, *QueryFilter) (*Queries, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedQueryServiceServer) Get(context.Context, *IdMessage) (*Query, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (UnimplementedQueryServiceServer) Create(context.Context, *QueryCreate) (*IdMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (UnimplementedQueryServiceServer) Update(context.Context, *QueryUpdate) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (UnimplementedQueryServiceServer) Remove(context.Context, *IdMessage) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Remove not implemented")
}
func (UnimplementedQueryServiceServer) Test(context.Context, *QueryTestRequest) (*QueryTestResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Test not implemented")
}
func (UnimplementedQueryServiceServer) mustEmbedUnimplementedQueryServiceServer() {}
func (UnimplementedQueryServiceServer) testEmbeddedByValue()                      {}

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

func RegisterQueryServiceServer(s grpc.ServiceRegistrar, srv QueryServiceServer) {
	// If the following call pancis, it indicates UnimplementedQueryServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&QueryService_ServiceDesc, srv)
}

func _QueryService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryFilter)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: QueryService_List_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).List(ctx, req.(*QueryFilter))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: QueryService_Get_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).Get(ctx, req.(*IdMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: QueryService_Create_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).Create(ctx, req.(*QueryCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryUpdate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: QueryService_Update_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).Update(ctx, req.(*QueryUpdate))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryService_Remove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).Remove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: QueryService_Remove_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).Remove(ctx, req.(*IdMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryService_Test_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryTestRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).Test(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: QueryService_Test_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).Test(ctx, req.(*QueryTestRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// QueryService_ServiceDesc is the grpc.ServiceDesc for QueryService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var QueryService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "queryorchestration.QueryService",
	HandlerType: (*QueryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _QueryService_List_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _QueryService_Get_Handler,
		},
		{
			MethodName: "Create",
			Handler:    _QueryService_Create_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _QueryService_Update_Handler,
		},
		{
			MethodName: "Remove",
			Handler:    _QueryService_Remove_Handler,
		},
		{
			MethodName: "Test",
			Handler:    _QueryService_Test_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "main.proto",
}

const (
	JobCollectorService_Create_FullMethodName = "/queryorchestration.JobCollectorService/Create"
	JobCollectorService_Update_FullMethodName = "/queryorchestration.JobCollectorService/Update"
	JobCollectorService_Get_FullMethodName    = "/queryorchestration.JobCollectorService/Get"
)

// JobCollectorServiceClient is the client API for JobCollectorService 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 JobCollectorServiceClient interface {
	Create(ctx context.Context, in *JobCollectorCreate, opts ...grpc.CallOption) (*IdMessage, error)
	Update(ctx context.Context, in *JobCollectorUpdate, opts ...grpc.CallOption) (*empty.Empty, error)
	Get(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*JobCollector, error)
}

type jobCollectorServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewJobCollectorServiceClient(cc grpc.ClientConnInterface) JobCollectorServiceClient {
	return &jobCollectorServiceClient{cc}
}

func (c *jobCollectorServiceClient) Create(ctx context.Context, in *JobCollectorCreate, opts ...grpc.CallOption) (*IdMessage, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IdMessage)
	err := c.cc.Invoke(ctx, JobCollectorService_Create_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobCollectorServiceClient) Update(ctx context.Context, in *JobCollectorUpdate, opts ...grpc.CallOption) (*empty.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, JobCollectorService_Update_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobCollectorServiceClient) Get(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*JobCollector, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(JobCollector)
	err := c.cc.Invoke(ctx, JobCollectorService_Get_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// JobCollectorServiceServer is the server API for JobCollectorService service.
// All implementations must embed UnimplementedJobCollectorServiceServer
// for forward compatibility.
type JobCollectorServiceServer interface {
	Create(context.Context, *JobCollectorCreate) (*IdMessage, error)
	Update(context.Context, *JobCollectorUpdate) (*empty.Empty, error)
	Get(context.Context, *IdMessage) (*JobCollector, error)
	mustEmbedUnimplementedJobCollectorServiceServer()
}

// UnimplementedJobCollectorServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedJobCollectorServiceServer struct{}

func (UnimplementedJobCollectorServiceServer) Create(context.Context, *JobCollectorCreate) (*IdMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (UnimplementedJobCollectorServiceServer) Update(context.Context, *JobCollectorUpdate) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (UnimplementedJobCollectorServiceServer) Get(context.Context, *IdMessage) (*JobCollector, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (UnimplementedJobCollectorServiceServer) mustEmbedUnimplementedJobCollectorServiceServer() {}
func (UnimplementedJobCollectorServiceServer) testEmbeddedByValue()                             {}

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

func RegisterJobCollectorServiceServer(s grpc.ServiceRegistrar, srv JobCollectorServiceServer) {
	// If the following call pancis, it indicates UnimplementedJobCollectorServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&JobCollectorService_ServiceDesc, srv)
}

func _JobCollectorService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JobCollectorCreate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobCollectorServiceServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: JobCollectorService_Create_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobCollectorServiceServer).Create(ctx, req.(*JobCollectorCreate))
	}
	return interceptor(ctx, in, info, handler)
}

func _JobCollectorService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JobCollectorUpdate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobCollectorServiceServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: JobCollectorService_Update_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobCollectorServiceServer).Update(ctx, req.(*JobCollectorUpdate))
	}
	return interceptor(ctx, in, info, handler)
}

func _JobCollectorService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobCollectorServiceServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: JobCollectorService_Get_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobCollectorServiceServer).Get(ctx, req.(*IdMessage))
	}
	return interceptor(ctx, in, info, handler)
}

// JobCollectorService_ServiceDesc is the grpc.ServiceDesc for JobCollectorService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var JobCollectorService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "queryorchestration.JobCollectorService",
	HandlerType: (*JobCollectorServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _JobCollectorService_Create_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _JobCollectorService_Update_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _JobCollectorService_Get_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "main.proto",
}

const (
	ExportService_Trigger_FullMethodName = "/queryorchestration.ExportService/Trigger"
)

// ExportServiceClient is the client API for ExportService 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 ExportServiceClient interface {
	Trigger(ctx context.Context, in *ExportTrigger, opts ...grpc.CallOption) (*IdMessage, error)
}

type exportServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewExportServiceClient(cc grpc.ClientConnInterface) ExportServiceClient {
	return &exportServiceClient{cc}
}

func (c *exportServiceClient) Trigger(ctx context.Context, in *ExportTrigger, opts ...grpc.CallOption) (*IdMessage, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IdMessage)
	err := c.cc.Invoke(ctx, ExportService_Trigger_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ExportServiceServer is the server API for ExportService service.
// All implementations must embed UnimplementedExportServiceServer
// for forward compatibility.
type ExportServiceServer interface {
	Trigger(context.Context, *ExportTrigger) (*IdMessage, error)
	mustEmbedUnimplementedExportServiceServer()
}

// UnimplementedExportServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedExportServiceServer struct{}

func (UnimplementedExportServiceServer) Trigger(context.Context, *ExportTrigger) (*IdMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Trigger not implemented")
}
func (UnimplementedExportServiceServer) mustEmbedUnimplementedExportServiceServer() {}
func (UnimplementedExportServiceServer) testEmbeddedByValue()                       {}

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

func RegisterExportServiceServer(s grpc.ServiceRegistrar, srv ExportServiceServer) {
	// If the following call pancis, it indicates UnimplementedExportServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&ExportService_ServiceDesc, srv)
}

func _ExportService_Trigger_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExportTrigger)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExportServiceServer).Trigger(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ExportService_Trigger_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExportServiceServer).Trigger(ctx, req.(*ExportTrigger))
	}
	return interceptor(ctx, in, info, handler)
}

// ExportService_ServiceDesc is the grpc.ServiceDesc for ExportService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ExportService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "queryorchestration.ExportService",
	HandlerType: (*ExportServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Trigger",
			Handler:    _ExportService_Trigger_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "main.proto",
}