query-orchestration/api/serviceInterfaces/main_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v5.28.3
// source: main.proto

package serviceinterfaces

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// 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

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_Deprecate_FullMethodName = "/queryorchestration.QueryService/Deprecate"
	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) (*emptypb.Empty, error)
	Deprecate(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*emptypb.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) {
	out := new(Queries)
	err := c.cc.Invoke(ctx, QueryService_List_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

func (c *queryServiceClient) Deprecate(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, QueryService_Deprecate_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryServiceClient) Test(ctx context.Context, in *QueryTestRequest, opts ...grpc.CallOption) (*QueryTestResponse, error) {
	out := new(QueryTestResponse)
	err := c.cc.Invoke(ctx, QueryService_Test_FullMethodName, in, out, opts...)
	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) (*emptypb.Empty, error)
	Deprecate(context.Context, *IdMessage) (*emptypb.Empty, error)
	Test(context.Context, *QueryTestRequest) (*QueryTestResponse, error)
	mustEmbedUnimplementedQueryServiceServer()
}

// UnimplementedQueryServiceServer must be embedded to have forward compatible implementations.
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) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (UnimplementedQueryServiceServer) Deprecate(context.Context, *IdMessage) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Deprecate not implemented")
}
func (UnimplementedQueryServiceServer) Test(context.Context, *QueryTestRequest) (*QueryTestResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Test not implemented")
}
func (UnimplementedQueryServiceServer) mustEmbedUnimplementedQueryServiceServer() {}

// 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) {
	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_Deprecate_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).Deprecate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: QueryService_Deprecate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).Deprecate(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: "Deprecate",
			Handler:    _QueryService_Deprecate_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) (*emptypb.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) {
	out := new(IdMessage)
	err := c.cc.Invoke(ctx, JobCollectorService_Create_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *jobCollectorServiceClient) Get(ctx context.Context, in *IdMessage, opts ...grpc.CallOption) (*JobCollector, error) {
	out := new(JobCollector)
	err := c.cc.Invoke(ctx, JobCollectorService_Get_FullMethodName, in, out, opts...)
	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) (*emptypb.Empty, error)
	Get(context.Context, *IdMessage) (*JobCollector, error)
	mustEmbedUnimplementedJobCollectorServiceServer()
}

// UnimplementedJobCollectorServiceServer must be embedded to have forward compatible implementations.
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) (*emptypb.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() {}

// 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) {
	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) {
	out := new(IdMessage)
	err := c.cc.Invoke(ctx, ExportService_Trigger_FullMethodName, in, out, opts...)
	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.
type UnimplementedExportServiceServer struct {
}

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

// 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) {
	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",
}