api_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.4.0
// - protoc             (unknown)
// source: api/v1/api.proto

package apiv1

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

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

const (
	PipelineService_ListPipelines_FullMethodName  = "/api.v1.PipelineService/ListPipelines"
	PipelineService_CreatePipeline_FullMethodName = "/api.v1.PipelineService/CreatePipeline"
	PipelineService_GetPipeline_FullMethodName    = "/api.v1.PipelineService/GetPipeline"
	PipelineService_UpdatePipeline_FullMethodName = "/api.v1.PipelineService/UpdatePipeline"
	PipelineService_DeletePipeline_FullMethodName = "/api.v1.PipelineService/DeletePipeline"
	PipelineService_StartPipeline_FullMethodName  = "/api.v1.PipelineService/StartPipeline"
	PipelineService_StopPipeline_FullMethodName   = "/api.v1.PipelineService/StopPipeline"
	PipelineService_GetDLQ_FullMethodName         = "/api.v1.PipelineService/GetDLQ"
	PipelineService_UpdateDLQ_FullMethodName      = "/api.v1.PipelineService/UpdateDLQ"
	PipelineService_ExportPipeline_FullMethodName = "/api.v1.PipelineService/ExportPipeline"
	PipelineService_ImportPipeline_FullMethodName = "/api.v1.PipelineService/ImportPipeline"
)

// PipelineServiceClient is the client API for PipelineService 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.
//
// PipelineService exposes functionality for managing pipelines.
// Endpoints in this service can be used to create, fetch, modify or delete a
// pipeline. Entities connected to a pipeline (e.g. processors, connectors) can
// be fetched together with a pipeline, although they can not be modified
// through this service. Modifying these entities needs to be done through the
// service responsible for managing the corresponding entity.
type PipelineServiceClient interface {
	ListPipelines(ctx context.Context, in *ListPipelinesRequest, opts ...grpc.CallOption) (*ListPipelinesResponse, error)
	CreatePipeline(ctx context.Context, in *CreatePipelineRequest, opts ...grpc.CallOption) (*CreatePipelineResponse, error)
	GetPipeline(ctx context.Context, in *GetPipelineRequest, opts ...grpc.CallOption) (*GetPipelineResponse, error)
	UpdatePipeline(ctx context.Context, in *UpdatePipelineRequest, opts ...grpc.CallOption) (*UpdatePipelineResponse, error)
	DeletePipeline(ctx context.Context, in *DeletePipelineRequest, opts ...grpc.CallOption) (*DeletePipelineResponse, error)
	StartPipeline(ctx context.Context, in *StartPipelineRequest, opts ...grpc.CallOption) (*StartPipelineResponse, error)
	StopPipeline(ctx context.Context, in *StopPipelineRequest, opts ...grpc.CallOption) (*StopPipelineResponse, error)
	GetDLQ(ctx context.Context, in *GetDLQRequest, opts ...grpc.CallOption) (*GetDLQResponse, error)
	UpdateDLQ(ctx context.Context, in *UpdateDLQRequest, opts ...grpc.CallOption) (*UpdateDLQResponse, error)
	ExportPipeline(ctx context.Context, in *ExportPipelineRequest, opts ...grpc.CallOption) (*ExportPipelineResponse, error)
	ImportPipeline(ctx context.Context, in *ImportPipelineRequest, opts ...grpc.CallOption) (*ImportPipelineResponse, error)
}

type pipelineServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewPipelineServiceClient(cc grpc.ClientConnInterface) PipelineServiceClient {
	return &pipelineServiceClient{cc}
}

func (c *pipelineServiceClient) ListPipelines(ctx context.Context, in *ListPipelinesRequest, opts ...grpc.CallOption) (*ListPipelinesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPipelinesResponse)
	err := c.cc.Invoke(ctx, PipelineService_ListPipelines_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) CreatePipeline(ctx context.Context, in *CreatePipelineRequest, opts ...grpc.CallOption) (*CreatePipelineResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreatePipelineResponse)
	err := c.cc.Invoke(ctx, PipelineService_CreatePipeline_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) GetPipeline(ctx context.Context, in *GetPipelineRequest, opts ...grpc.CallOption) (*GetPipelineResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetPipelineResponse)
	err := c.cc.Invoke(ctx, PipelineService_GetPipeline_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) UpdatePipeline(ctx context.Context, in *UpdatePipelineRequest, opts ...grpc.CallOption) (*UpdatePipelineResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdatePipelineResponse)
	err := c.cc.Invoke(ctx, PipelineService_UpdatePipeline_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) DeletePipeline(ctx context.Context, in *DeletePipelineRequest, opts ...grpc.CallOption) (*DeletePipelineResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeletePipelineResponse)
	err := c.cc.Invoke(ctx, PipelineService_DeletePipeline_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) StartPipeline(ctx context.Context, in *StartPipelineRequest, opts ...grpc.CallOption) (*StartPipelineResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StartPipelineResponse)
	err := c.cc.Invoke(ctx, PipelineService_StartPipeline_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) StopPipeline(ctx context.Context, in *StopPipelineRequest, opts ...grpc.CallOption) (*StopPipelineResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StopPipelineResponse)
	err := c.cc.Invoke(ctx, PipelineService_StopPipeline_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) GetDLQ(ctx context.Context, in *GetDLQRequest, opts ...grpc.CallOption) (*GetDLQResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetDLQResponse)
	err := c.cc.Invoke(ctx, PipelineService_GetDLQ_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) UpdateDLQ(ctx context.Context, in *UpdateDLQRequest, opts ...grpc.CallOption) (*UpdateDLQResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateDLQResponse)
	err := c.cc.Invoke(ctx, PipelineService_UpdateDLQ_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) ExportPipeline(ctx context.Context, in *ExportPipelineRequest, opts ...grpc.CallOption) (*ExportPipelineResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ExportPipelineResponse)
	err := c.cc.Invoke(ctx, PipelineService_ExportPipeline_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pipelineServiceClient) ImportPipeline(ctx context.Context, in *ImportPipelineRequest, opts ...grpc.CallOption) (*ImportPipelineResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ImportPipelineResponse)
	err := c.cc.Invoke(ctx, PipelineService_ImportPipeline_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PipelineServiceServer is the server API for PipelineService service.
// All implementations must embed UnimplementedPipelineServiceServer
// for forward compatibility
//
// PipelineService exposes functionality for managing pipelines.
// Endpoints in this service can be used to create, fetch, modify or delete a
// pipeline. Entities connected to a pipeline (e.g. processors, connectors) can
// be fetched together with a pipeline, although they can not be modified
// through this service. Modifying these entities needs to be done through the
// service responsible for managing the corresponding entity.
type PipelineServiceServer interface {
	ListPipelines(context.Context, *ListPipelinesRequest) (*ListPipelinesResponse, error)
	CreatePipeline(context.Context, *CreatePipelineRequest) (*CreatePipelineResponse, error)
	GetPipeline(context.Context, *GetPipelineRequest) (*GetPipelineResponse, error)
	UpdatePipeline(context.Context, *UpdatePipelineRequest) (*UpdatePipelineResponse, error)
	DeletePipeline(context.Context, *DeletePipelineRequest) (*DeletePipelineResponse, error)
	StartPipeline(context.Context, *StartPipelineRequest) (*StartPipelineResponse, error)
	StopPipeline(context.Context, *StopPipelineRequest) (*StopPipelineResponse, error)
	GetDLQ(context.Context, *GetDLQRequest) (*GetDLQResponse, error)
	UpdateDLQ(context.Context, *UpdateDLQRequest) (*UpdateDLQResponse, error)
	ExportPipeline(context.Context, *ExportPipelineRequest) (*ExportPipelineResponse, error)
	ImportPipeline(context.Context, *ImportPipelineRequest) (*ImportPipelineResponse, error)
	mustEmbedUnimplementedPipelineServiceServer()
}

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

func (UnimplementedPipelineServiceServer) ListPipelines(context.Context, *ListPipelinesRequest) (*ListPipelinesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPipelines not implemented")
}
func (UnimplementedPipelineServiceServer) CreatePipeline(context.Context, *CreatePipelineRequest) (*CreatePipelineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePipeline not implemented")
}
func (UnimplementedPipelineServiceServer) GetPipeline(context.Context, *GetPipelineRequest) (*GetPipelineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPipeline not implemented")
}
func (UnimplementedPipelineServiceServer) UpdatePipeline(context.Context, *UpdatePipelineRequest) (*UpdatePipelineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdatePipeline not implemented")
}
func (UnimplementedPipelineServiceServer) DeletePipeline(context.Context, *DeletePipelineRequest) (*DeletePipelineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePipeline not implemented")
}
func (UnimplementedPipelineServiceServer) StartPipeline(context.Context, *StartPipelineRequest) (*StartPipelineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartPipeline not implemented")
}
func (UnimplementedPipelineServiceServer) StopPipeline(context.Context, *StopPipelineRequest) (*StopPipelineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopPipeline not implemented")
}
func (UnimplementedPipelineServiceServer) GetDLQ(context.Context, *GetDLQRequest) (*GetDLQResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDLQ not implemented")
}
func (UnimplementedPipelineServiceServer) UpdateDLQ(context.Context, *UpdateDLQRequest) (*UpdateDLQResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateDLQ not implemented")
}
func (UnimplementedPipelineServiceServer) ExportPipeline(context.Context, *ExportPipelineRequest) (*ExportPipelineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExportPipeline not implemented")
}
func (UnimplementedPipelineServiceServer) ImportPipeline(context.Context, *ImportPipelineRequest) (*ImportPipelineResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportPipeline not implemented")
}
func (UnimplementedPipelineServiceServer) mustEmbedUnimplementedPipelineServiceServer() {}

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

func RegisterPipelineServiceServer(s grpc.ServiceRegistrar, srv PipelineServiceServer) {
	s.RegisterService(&PipelineService_ServiceDesc, srv)
}

func _PipelineService_ListPipelines_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPipelinesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).ListPipelines(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_ListPipelines_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).ListPipelines(ctx, req.(*ListPipelinesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_CreatePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).CreatePipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_CreatePipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).CreatePipeline(ctx, req.(*CreatePipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_GetPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).GetPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_GetPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).GetPipeline(ctx, req.(*GetPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_UpdatePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdatePipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).UpdatePipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_UpdatePipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).UpdatePipeline(ctx, req.(*UpdatePipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_DeletePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).DeletePipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_DeletePipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).DeletePipeline(ctx, req.(*DeletePipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_StartPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).StartPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_StartPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).StartPipeline(ctx, req.(*StartPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_StopPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).StopPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_StopPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).StopPipeline(ctx, req.(*StopPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_GetDLQ_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDLQRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).GetDLQ(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_GetDLQ_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).GetDLQ(ctx, req.(*GetDLQRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_UpdateDLQ_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateDLQRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).UpdateDLQ(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_UpdateDLQ_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).UpdateDLQ(ctx, req.(*UpdateDLQRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_ExportPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExportPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).ExportPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_ExportPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).ExportPipeline(ctx, req.(*ExportPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PipelineService_ImportPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PipelineServiceServer).ImportPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PipelineService_ImportPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PipelineServiceServer).ImportPipeline(ctx, req.(*ImportPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// PipelineService_ServiceDesc is the grpc.ServiceDesc for PipelineService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var PipelineService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.v1.PipelineService",
	HandlerType: (*PipelineServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListPipelines",
			Handler:    _PipelineService_ListPipelines_Handler,
		},
		{
			MethodName: "CreatePipeline",
			Handler:    _PipelineService_CreatePipeline_Handler,
		},
		{
			MethodName: "GetPipeline",
			Handler:    _PipelineService_GetPipeline_Handler,
		},
		{
			MethodName: "UpdatePipeline",
			Handler:    _PipelineService_UpdatePipeline_Handler,
		},
		{
			MethodName: "DeletePipeline",
			Handler:    _PipelineService_DeletePipeline_Handler,
		},
		{
			MethodName: "StartPipeline",
			Handler:    _PipelineService_StartPipeline_Handler,
		},
		{
			MethodName: "StopPipeline",
			Handler:    _PipelineService_StopPipeline_Handler,
		},
		{
			MethodName: "GetDLQ",
			Handler:    _PipelineService_GetDLQ_Handler,
		},
		{
			MethodName: "UpdateDLQ",
			Handler:    _PipelineService_UpdateDLQ_Handler,
		},
		{
			MethodName: "ExportPipeline",
			Handler:    _PipelineService_ExportPipeline_Handler,
		},
		{
			MethodName: "ImportPipeline",
			Handler:    _PipelineService_ImportPipeline_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api/v1/api.proto",
}

const (
	ConnectorService_ListConnectors_FullMethodName       = "/api.v1.ConnectorService/ListConnectors"
	ConnectorService_InspectConnector_FullMethodName     = "/api.v1.ConnectorService/InspectConnector"
	ConnectorService_GetConnector_FullMethodName         = "/api.v1.ConnectorService/GetConnector"
	ConnectorService_CreateConnector_FullMethodName      = "/api.v1.ConnectorService/CreateConnector"
	ConnectorService_ValidateConnector_FullMethodName    = "/api.v1.ConnectorService/ValidateConnector"
	ConnectorService_UpdateConnector_FullMethodName      = "/api.v1.ConnectorService/UpdateConnector"
	ConnectorService_DeleteConnector_FullMethodName      = "/api.v1.ConnectorService/DeleteConnector"
	ConnectorService_ListConnectorPlugins_FullMethodName = "/api.v1.ConnectorService/ListConnectorPlugins"
)

// ConnectorServiceClient is the client API for ConnectorService 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.
//
// ConnectorService exposes CRUD functionality for managing connectors.
type ConnectorServiceClient interface {
	ListConnectors(ctx context.Context, in *ListConnectorsRequest, opts ...grpc.CallOption) (*ListConnectorsResponse, error)
	InspectConnector(ctx context.Context, in *InspectConnectorRequest, opts ...grpc.CallOption) (ConnectorService_InspectConnectorClient, error)
	GetConnector(ctx context.Context, in *GetConnectorRequest, opts ...grpc.CallOption) (*GetConnectorResponse, error)
	CreateConnector(ctx context.Context, in *CreateConnectorRequest, opts ...grpc.CallOption) (*CreateConnectorResponse, error)
	ValidateConnector(ctx context.Context, in *ValidateConnectorRequest, opts ...grpc.CallOption) (*ValidateConnectorResponse, error)
	UpdateConnector(ctx context.Context, in *UpdateConnectorRequest, opts ...grpc.CallOption) (*UpdateConnectorResponse, error)
	DeleteConnector(ctx context.Context, in *DeleteConnectorRequest, opts ...grpc.CallOption) (*DeleteConnectorResponse, error)
	ListConnectorPlugins(ctx context.Context, in *ListConnectorPluginsRequest, opts ...grpc.CallOption) (*ListConnectorPluginsResponse, error)
}

type connectorServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewConnectorServiceClient(cc grpc.ClientConnInterface) ConnectorServiceClient {
	return &connectorServiceClient{cc}
}

func (c *connectorServiceClient) ListConnectors(ctx context.Context, in *ListConnectorsRequest, opts ...grpc.CallOption) (*ListConnectorsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListConnectorsResponse)
	err := c.cc.Invoke(ctx, ConnectorService_ListConnectors_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) InspectConnector(ctx context.Context, in *InspectConnectorRequest, opts ...grpc.CallOption) (ConnectorService_InspectConnectorClient, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &ConnectorService_ServiceDesc.Streams[0], ConnectorService_InspectConnector_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &connectorServiceInspectConnectorClient{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ConnectorService_InspectConnectorClient interface {
	Recv() (*InspectConnectorResponse, error)
	grpc.ClientStream
}

type connectorServiceInspectConnectorClient struct {
	grpc.ClientStream
}

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

func (c *connectorServiceClient) GetConnector(ctx context.Context, in *GetConnectorRequest, opts ...grpc.CallOption) (*GetConnectorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetConnectorResponse)
	err := c.cc.Invoke(ctx, ConnectorService_GetConnector_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) CreateConnector(ctx context.Context, in *CreateConnectorRequest, opts ...grpc.CallOption) (*CreateConnectorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateConnectorResponse)
	err := c.cc.Invoke(ctx, ConnectorService_CreateConnector_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) ValidateConnector(ctx context.Context, in *ValidateConnectorRequest, opts ...grpc.CallOption) (*ValidateConnectorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ValidateConnectorResponse)
	err := c.cc.Invoke(ctx, ConnectorService_ValidateConnector_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) UpdateConnector(ctx context.Context, in *UpdateConnectorRequest, opts ...grpc.CallOption) (*UpdateConnectorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateConnectorResponse)
	err := c.cc.Invoke(ctx, ConnectorService_UpdateConnector_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) DeleteConnector(ctx context.Context, in *DeleteConnectorRequest, opts ...grpc.CallOption) (*DeleteConnectorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteConnectorResponse)
	err := c.cc.Invoke(ctx, ConnectorService_DeleteConnector_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) ListConnectorPlugins(ctx context.Context, in *ListConnectorPluginsRequest, opts ...grpc.CallOption) (*ListConnectorPluginsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListConnectorPluginsResponse)
	err := c.cc.Invoke(ctx, ConnectorService_ListConnectorPlugins_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ConnectorServiceServer is the server API for ConnectorService service.
// All implementations must embed UnimplementedConnectorServiceServer
// for forward compatibility
//
// ConnectorService exposes CRUD functionality for managing connectors.
type ConnectorServiceServer interface {
	ListConnectors(context.Context, *ListConnectorsRequest) (*ListConnectorsResponse, error)
	InspectConnector(*InspectConnectorRequest, ConnectorService_InspectConnectorServer) error
	GetConnector(context.Context, *GetConnectorRequest) (*GetConnectorResponse, error)
	CreateConnector(context.Context, *CreateConnectorRequest) (*CreateConnectorResponse, error)
	ValidateConnector(context.Context, *ValidateConnectorRequest) (*ValidateConnectorResponse, error)
	UpdateConnector(context.Context, *UpdateConnectorRequest) (*UpdateConnectorResponse, error)
	DeleteConnector(context.Context, *DeleteConnectorRequest) (*DeleteConnectorResponse, error)
	ListConnectorPlugins(context.Context, *ListConnectorPluginsRequest) (*ListConnectorPluginsResponse, error)
	mustEmbedUnimplementedConnectorServiceServer()
}

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

func (UnimplementedConnectorServiceServer) ListConnectors(context.Context, *ListConnectorsRequest) (*ListConnectorsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListConnectors not implemented")
}
func (UnimplementedConnectorServiceServer) InspectConnector(*InspectConnectorRequest, ConnectorService_InspectConnectorServer) error {
	return status.Errorf(codes.Unimplemented, "method InspectConnector not implemented")
}
func (UnimplementedConnectorServiceServer) GetConnector(context.Context, *GetConnectorRequest) (*GetConnectorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConnector not implemented")
}
func (UnimplementedConnectorServiceServer) CreateConnector(context.Context, *CreateConnectorRequest) (*CreateConnectorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateConnector not implemented")
}
func (UnimplementedConnectorServiceServer) ValidateConnector(context.Context, *ValidateConnectorRequest) (*ValidateConnectorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateConnector not implemented")
}
func (UnimplementedConnectorServiceServer) UpdateConnector(context.Context, *UpdateConnectorRequest) (*UpdateConnectorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateConnector not implemented")
}
func (UnimplementedConnectorServiceServer) DeleteConnector(context.Context, *DeleteConnectorRequest) (*DeleteConnectorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteConnector not implemented")
}
func (UnimplementedConnectorServiceServer) ListConnectorPlugins(context.Context, *ListConnectorPluginsRequest) (*ListConnectorPluginsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListConnectorPlugins not implemented")
}
func (UnimplementedConnectorServiceServer) mustEmbedUnimplementedConnectorServiceServer() {}

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

func RegisterConnectorServiceServer(s grpc.ServiceRegistrar, srv ConnectorServiceServer) {
	s.RegisterService(&ConnectorService_ServiceDesc, srv)
}

func _ConnectorService_ListConnectors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListConnectorsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).ListConnectors(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_ListConnectors_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).ListConnectors(ctx, req.(*ListConnectorsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_InspectConnector_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InspectConnectorRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ConnectorServiceServer).InspectConnector(m, &connectorServiceInspectConnectorServer{ServerStream: stream})
}

type ConnectorService_InspectConnectorServer interface {
	Send(*InspectConnectorResponse) error
	grpc.ServerStream
}

type connectorServiceInspectConnectorServer struct {
	grpc.ServerStream
}

func (x *connectorServiceInspectConnectorServer) Send(m *InspectConnectorResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ConnectorService_GetConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetConnectorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetConnector(ctx, req.(*GetConnectorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_CreateConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateConnectorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).CreateConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_CreateConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).CreateConnector(ctx, req.(*CreateConnectorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_ValidateConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidateConnectorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).ValidateConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_ValidateConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).ValidateConnector(ctx, req.(*ValidateConnectorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_UpdateConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateConnectorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).UpdateConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_UpdateConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).UpdateConnector(ctx, req.(*UpdateConnectorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_DeleteConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteConnectorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).DeleteConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_DeleteConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).DeleteConnector(ctx, req.(*DeleteConnectorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_ListConnectorPlugins_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListConnectorPluginsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).ListConnectorPlugins(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_ListConnectorPlugins_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).ListConnectorPlugins(ctx, req.(*ListConnectorPluginsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ConnectorService_ServiceDesc is the grpc.ServiceDesc for ConnectorService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ConnectorService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.v1.ConnectorService",
	HandlerType: (*ConnectorServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListConnectors",
			Handler:    _ConnectorService_ListConnectors_Handler,
		},
		{
			MethodName: "GetConnector",
			Handler:    _ConnectorService_GetConnector_Handler,
		},
		{
			MethodName: "CreateConnector",
			Handler:    _ConnectorService_CreateConnector_Handler,
		},
		{
			MethodName: "ValidateConnector",
			Handler:    _ConnectorService_ValidateConnector_Handler,
		},
		{
			MethodName: "UpdateConnector",
			Handler:    _ConnectorService_UpdateConnector_Handler,
		},
		{
			MethodName: "DeleteConnector",
			Handler:    _ConnectorService_DeleteConnector_Handler,
		},
		{
			MethodName: "ListConnectorPlugins",
			Handler:    _ConnectorService_ListConnectorPlugins_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "InspectConnector",
			Handler:       _ConnectorService_InspectConnector_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api/v1/api.proto",
}

const (
	ProcessorService_ListProcessors_FullMethodName       = "/api.v1.ProcessorService/ListProcessors"
	ProcessorService_InspectProcessorIn_FullMethodName   = "/api.v1.ProcessorService/InspectProcessorIn"
	ProcessorService_InspectProcessorOut_FullMethodName  = "/api.v1.ProcessorService/InspectProcessorOut"
	ProcessorService_GetProcessor_FullMethodName         = "/api.v1.ProcessorService/GetProcessor"
	ProcessorService_CreateProcessor_FullMethodName      = "/api.v1.ProcessorService/CreateProcessor"
	ProcessorService_UpdateProcessor_FullMethodName      = "/api.v1.ProcessorService/UpdateProcessor"
	ProcessorService_DeleteProcessor_FullMethodName      = "/api.v1.ProcessorService/DeleteProcessor"
	ProcessorService_ListProcessorPlugins_FullMethodName = "/api.v1.ProcessorService/ListProcessorPlugins"
)

// ProcessorServiceClient is the client API for ProcessorService 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.
//
// ProcessorService exposes CRUD functionality for managing processors.
type ProcessorServiceClient interface {
	ListProcessors(ctx context.Context, in *ListProcessorsRequest, opts ...grpc.CallOption) (*ListProcessorsResponse, error)
	// InspectProcessorIn streams records coming into the specified processor
	InspectProcessorIn(ctx context.Context, in *InspectProcessorInRequest, opts ...grpc.CallOption) (ProcessorService_InspectProcessorInClient, error)
	// InspectProcessorOut streams the output records from the specified processor
	InspectProcessorOut(ctx context.Context, in *InspectProcessorOutRequest, opts ...grpc.CallOption) (ProcessorService_InspectProcessorOutClient, error)
	GetProcessor(ctx context.Context, in *GetProcessorRequest, opts ...grpc.CallOption) (*GetProcessorResponse, error)
	CreateProcessor(ctx context.Context, in *CreateProcessorRequest, opts ...grpc.CallOption) (*CreateProcessorResponse, error)
	UpdateProcessor(ctx context.Context, in *UpdateProcessorRequest, opts ...grpc.CallOption) (*UpdateProcessorResponse, error)
	DeleteProcessor(ctx context.Context, in *DeleteProcessorRequest, opts ...grpc.CallOption) (*DeleteProcessorResponse, error)
	ListProcessorPlugins(ctx context.Context, in *ListProcessorPluginsRequest, opts ...grpc.CallOption) (*ListProcessorPluginsResponse, error)
}

type processorServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewProcessorServiceClient(cc grpc.ClientConnInterface) ProcessorServiceClient {
	return &processorServiceClient{cc}
}

func (c *processorServiceClient) ListProcessors(ctx context.Context, in *ListProcessorsRequest, opts ...grpc.CallOption) (*ListProcessorsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListProcessorsResponse)
	err := c.cc.Invoke(ctx, ProcessorService_ListProcessors_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *processorServiceClient) InspectProcessorIn(ctx context.Context, in *InspectProcessorInRequest, opts ...grpc.CallOption) (ProcessorService_InspectProcessorInClient, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &ProcessorService_ServiceDesc.Streams[0], ProcessorService_InspectProcessorIn_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &processorServiceInspectProcessorInClient{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProcessorService_InspectProcessorInClient interface {
	Recv() (*InspectProcessorInResponse, error)
	grpc.ClientStream
}

type processorServiceInspectProcessorInClient struct {
	grpc.ClientStream
}

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

func (c *processorServiceClient) InspectProcessorOut(ctx context.Context, in *InspectProcessorOutRequest, opts ...grpc.CallOption) (ProcessorService_InspectProcessorOutClient, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &ProcessorService_ServiceDesc.Streams[1], ProcessorService_InspectProcessorOut_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &processorServiceInspectProcessorOutClient{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ProcessorService_InspectProcessorOutClient interface {
	Recv() (*InspectProcessorOutResponse, error)
	grpc.ClientStream
}

type processorServiceInspectProcessorOutClient struct {
	grpc.ClientStream
}

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

func (c *processorServiceClient) GetProcessor(ctx context.Context, in *GetProcessorRequest, opts ...grpc.CallOption) (*GetProcessorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetProcessorResponse)
	err := c.cc.Invoke(ctx, ProcessorService_GetProcessor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *processorServiceClient) CreateProcessor(ctx context.Context, in *CreateProcessorRequest, opts ...grpc.CallOption) (*CreateProcessorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateProcessorResponse)
	err := c.cc.Invoke(ctx, ProcessorService_CreateProcessor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *processorServiceClient) UpdateProcessor(ctx context.Context, in *UpdateProcessorRequest, opts ...grpc.CallOption) (*UpdateProcessorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateProcessorResponse)
	err := c.cc.Invoke(ctx, ProcessorService_UpdateProcessor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *processorServiceClient) DeleteProcessor(ctx context.Context, in *DeleteProcessorRequest, opts ...grpc.CallOption) (*DeleteProcessorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteProcessorResponse)
	err := c.cc.Invoke(ctx, ProcessorService_DeleteProcessor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *processorServiceClient) ListProcessorPlugins(ctx context.Context, in *ListProcessorPluginsRequest, opts ...grpc.CallOption) (*ListProcessorPluginsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListProcessorPluginsResponse)
	err := c.cc.Invoke(ctx, ProcessorService_ListProcessorPlugins_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProcessorServiceServer is the server API for ProcessorService service.
// All implementations must embed UnimplementedProcessorServiceServer
// for forward compatibility
//
// ProcessorService exposes CRUD functionality for managing processors.
type ProcessorServiceServer interface {
	ListProcessors(context.Context, *ListProcessorsRequest) (*ListProcessorsResponse, error)
	// InspectProcessorIn streams records coming into the specified processor
	InspectProcessorIn(*InspectProcessorInRequest, ProcessorService_InspectProcessorInServer) error
	// InspectProcessorOut streams the output records from the specified processor
	InspectProcessorOut(*InspectProcessorOutRequest, ProcessorService_InspectProcessorOutServer) error
	GetProcessor(context.Context, *GetProcessorRequest) (*GetProcessorResponse, error)
	CreateProcessor(context.Context, *CreateProcessorRequest) (*CreateProcessorResponse, error)
	UpdateProcessor(context.Context, *UpdateProcessorRequest) (*UpdateProcessorResponse, error)
	DeleteProcessor(context.Context, *DeleteProcessorRequest) (*DeleteProcessorResponse, error)
	ListProcessorPlugins(context.Context, *ListProcessorPluginsRequest) (*ListProcessorPluginsResponse, error)
	mustEmbedUnimplementedProcessorServiceServer()
}

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

func (UnimplementedProcessorServiceServer) ListProcessors(context.Context, *ListProcessorsRequest) (*ListProcessorsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListProcessors not implemented")
}
func (UnimplementedProcessorServiceServer) InspectProcessorIn(*InspectProcessorInRequest, ProcessorService_InspectProcessorInServer) error {
	return status.Errorf(codes.Unimplemented, "method InspectProcessorIn not implemented")
}
func (UnimplementedProcessorServiceServer) InspectProcessorOut(*InspectProcessorOutRequest, ProcessorService_InspectProcessorOutServer) error {
	return status.Errorf(codes.Unimplemented, "method InspectProcessorOut not implemented")
}
func (UnimplementedProcessorServiceServer) GetProcessor(context.Context, *GetProcessorRequest) (*GetProcessorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProcessor not implemented")
}
func (UnimplementedProcessorServiceServer) CreateProcessor(context.Context, *CreateProcessorRequest) (*CreateProcessorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateProcessor not implemented")
}
func (UnimplementedProcessorServiceServer) UpdateProcessor(context.Context, *UpdateProcessorRequest) (*UpdateProcessorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateProcessor not implemented")
}
func (UnimplementedProcessorServiceServer) DeleteProcessor(context.Context, *DeleteProcessorRequest) (*DeleteProcessorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteProcessor not implemented")
}
func (UnimplementedProcessorServiceServer) ListProcessorPlugins(context.Context, *ListProcessorPluginsRequest) (*ListProcessorPluginsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListProcessorPlugins not implemented")
}
func (UnimplementedProcessorServiceServer) mustEmbedUnimplementedProcessorServiceServer() {}

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

func RegisterProcessorServiceServer(s grpc.ServiceRegistrar, srv ProcessorServiceServer) {
	s.RegisterService(&ProcessorService_ServiceDesc, srv)
}

func _ProcessorService_ListProcessors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListProcessorsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProcessorServiceServer).ListProcessors(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProcessorService_ListProcessors_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProcessorServiceServer).ListProcessors(ctx, req.(*ListProcessorsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProcessorService_InspectProcessorIn_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InspectProcessorInRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProcessorServiceServer).InspectProcessorIn(m, &processorServiceInspectProcessorInServer{ServerStream: stream})
}

type ProcessorService_InspectProcessorInServer interface {
	Send(*InspectProcessorInResponse) error
	grpc.ServerStream
}

type processorServiceInspectProcessorInServer struct {
	grpc.ServerStream
}

func (x *processorServiceInspectProcessorInServer) Send(m *InspectProcessorInResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ProcessorService_InspectProcessorOut_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InspectProcessorOutRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProcessorServiceServer).InspectProcessorOut(m, &processorServiceInspectProcessorOutServer{ServerStream: stream})
}

type ProcessorService_InspectProcessorOutServer interface {
	Send(*InspectProcessorOutResponse) error
	grpc.ServerStream
}

type processorServiceInspectProcessorOutServer struct {
	grpc.ServerStream
}

func (x *processorServiceInspectProcessorOutServer) Send(m *InspectProcessorOutResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ProcessorService_GetProcessor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProcessorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProcessorServiceServer).GetProcessor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProcessorService_GetProcessor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProcessorServiceServer).GetProcessor(ctx, req.(*GetProcessorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProcessorService_CreateProcessor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateProcessorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProcessorServiceServer).CreateProcessor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProcessorService_CreateProcessor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProcessorServiceServer).CreateProcessor(ctx, req.(*CreateProcessorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProcessorService_UpdateProcessor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateProcessorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProcessorServiceServer).UpdateProcessor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProcessorService_UpdateProcessor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProcessorServiceServer).UpdateProcessor(ctx, req.(*UpdateProcessorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProcessorService_DeleteProcessor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteProcessorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProcessorServiceServer).DeleteProcessor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProcessorService_DeleteProcessor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProcessorServiceServer).DeleteProcessor(ctx, req.(*DeleteProcessorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProcessorService_ListProcessorPlugins_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListProcessorPluginsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProcessorServiceServer).ListProcessorPlugins(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ProcessorService_ListProcessorPlugins_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProcessorServiceServer).ListProcessorPlugins(ctx, req.(*ListProcessorPluginsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ProcessorService_ServiceDesc is the grpc.ServiceDesc for ProcessorService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ProcessorService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.v1.ProcessorService",
	HandlerType: (*ProcessorServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListProcessors",
			Handler:    _ProcessorService_ListProcessors_Handler,
		},
		{
			MethodName: "GetProcessor",
			Handler:    _ProcessorService_GetProcessor_Handler,
		},
		{
			MethodName: "CreateProcessor",
			Handler:    _ProcessorService_CreateProcessor_Handler,
		},
		{
			MethodName: "UpdateProcessor",
			Handler:    _ProcessorService_UpdateProcessor_Handler,
		},
		{
			MethodName: "DeleteProcessor",
			Handler:    _ProcessorService_DeleteProcessor_Handler,
		},
		{
			MethodName: "ListProcessorPlugins",
			Handler:    _ProcessorService_ListProcessorPlugins_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "InspectProcessorIn",
			Handler:       _ProcessorService_InspectProcessorIn_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "InspectProcessorOut",
			Handler:       _ProcessorService_InspectProcessorOut_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api/v1/api.proto",
}

const (
	InformationService_GetInfo_FullMethodName = "/api.v1.InformationService/GetInfo"
)

// InformationServiceClient is the client API for InformationService 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 InformationServiceClient interface {
	GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error)
}

type informationServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewInformationServiceClient(cc grpc.ClientConnInterface) InformationServiceClient {
	return &informationServiceClient{cc}
}

func (c *informationServiceClient) GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetInfoResponse)
	err := c.cc.Invoke(ctx, InformationService_GetInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// InformationServiceServer is the server API for InformationService service.
// All implementations must embed UnimplementedInformationServiceServer
// for forward compatibility
type InformationServiceServer interface {
	GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error)
	mustEmbedUnimplementedInformationServiceServer()
}

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

func (UnimplementedInformationServiceServer) GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInfo not implemented")
}
func (UnimplementedInformationServiceServer) mustEmbedUnimplementedInformationServiceServer() {}

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

func RegisterInformationServiceServer(s grpc.ServiceRegistrar, srv InformationServiceServer) {
	s.RegisterService(&InformationService_ServiceDesc, srv)
}

func _InformationService_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InformationServiceServer).GetInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InformationService_GetInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InformationServiceServer).GetInfo(ctx, req.(*GetInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// InformationService_ServiceDesc is the grpc.ServiceDesc for InformationService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InformationService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.v1.InformationService",
	HandlerType: (*InformationServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetInfo",
			Handler:    _InformationService_GetInfo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api/v1/api.proto",
}

const (
	PluginService_ListPlugins_FullMethodName = "/api.v1.PluginService/ListPlugins"
)

// PluginServiceClient is the client API for PluginService 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.
//
// Deprecated: use ConnectorService and ProcessorService instead.
type PluginServiceClient interface {
	// Deprecated: Do not use.
	// Deprecated: use ConnectorService.ListConnectorPlugins instead.
	ListPlugins(ctx context.Context, in *ListPluginsRequest, opts ...grpc.CallOption) (*ListPluginsResponse, error)
}

type pluginServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewPluginServiceClient(cc grpc.ClientConnInterface) PluginServiceClient {
	return &pluginServiceClient{cc}
}

// Deprecated: Do not use.
func (c *pluginServiceClient) ListPlugins(ctx context.Context, in *ListPluginsRequest, opts ...grpc.CallOption) (*ListPluginsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPluginsResponse)
	err := c.cc.Invoke(ctx, PluginService_ListPlugins_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PluginServiceServer is the server API for PluginService service.
// All implementations must embed UnimplementedPluginServiceServer
// for forward compatibility
//
// Deprecated: use ConnectorService and ProcessorService instead.
type PluginServiceServer interface {
	// Deprecated: Do not use.
	// Deprecated: use ConnectorService.ListConnectorPlugins instead.
	ListPlugins(context.Context, *ListPluginsRequest) (*ListPluginsResponse, error)
	mustEmbedUnimplementedPluginServiceServer()
}

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

func (UnimplementedPluginServiceServer) ListPlugins(context.Context, *ListPluginsRequest) (*ListPluginsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPlugins not implemented")
}
func (UnimplementedPluginServiceServer) mustEmbedUnimplementedPluginServiceServer() {}

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

func RegisterPluginServiceServer(s grpc.ServiceRegistrar, srv PluginServiceServer) {
	s.RegisterService(&PluginService_ServiceDesc, srv)
}

func _PluginService_ListPlugins_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPluginsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PluginServiceServer).ListPlugins(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: PluginService_ListPlugins_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PluginServiceServer).ListPlugins(ctx, req.(*ListPluginsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// PluginService_ServiceDesc is the grpc.ServiceDesc for PluginService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var PluginService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.v1.PluginService",
	HandlerType: (*PluginServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListPlugins",
			Handler:    _PluginService_ListPlugins_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api/v1/api.proto",
}