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

package gen

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

// ProtoflowServiceClient is the client API for ProtoflowService 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 ProtoflowServiceClient interface {
	DownloadYouTubeVideo(ctx context.Context, in *YouTubeVideo, opts ...grpc.CallOption) (*YouTubeVideoResponse, error)
	GetSessions(ctx context.Context, in *GetSessionsRequest, opts ...grpc.CallOption) (*GetSessionsResponse, error)
	GetSession(ctx context.Context, in *GetSessionRequest, opts ...grpc.CallOption) (*GetSessionResponse, error)
	DeleteSession(ctx context.Context, in *DeleteSessionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetPrompts(ctx context.Context, in *GetPromptsRequest, opts ...grpc.CallOption) (*GetPromptsResponse, error)
	NewPrompt(ctx context.Context, in *Prompt, opts ...grpc.CallOption) (*Prompt, error)
	UploadContent(ctx context.Context, in *UploadContentRequest, opts ...grpc.CallOption) (ProtoflowService_UploadContentClient, error)
	Infer(ctx context.Context, in *InferRequest, opts ...grpc.CallOption) (ProtoflowService_InferClient, error)
	Chat(ctx context.Context, in *ChatRequest, opts ...grpc.CallOption) (ProtoflowService_ChatClient, error)
	ConvertFile(ctx context.Context, in *ConvertFileRequest, opts ...grpc.CallOption) (*FilePath, error)
	GenerateImages(ctx context.Context, in *GenerateImagesRequest, opts ...grpc.CallOption) (*GenerateImagesResponse, error)
	AnalyzeConversation(ctx context.Context, in *AnalyzeConversationRequest, opts ...grpc.CallOption) (*AnalyzeConversationResponse, error)
}

type protoflowServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewProtoflowServiceClient(cc grpc.ClientConnInterface) ProtoflowServiceClient {
	return &protoflowServiceClient{cc}
}

func (c *protoflowServiceClient) DownloadYouTubeVideo(ctx context.Context, in *YouTubeVideo, opts ...grpc.CallOption) (*YouTubeVideoResponse, error) {
	out := new(YouTubeVideoResponse)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/DownloadYouTubeVideo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protoflowServiceClient) GetSessions(ctx context.Context, in *GetSessionsRequest, opts ...grpc.CallOption) (*GetSessionsResponse, error) {
	out := new(GetSessionsResponse)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/GetSessions", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protoflowServiceClient) GetSession(ctx context.Context, in *GetSessionRequest, opts ...grpc.CallOption) (*GetSessionResponse, error) {
	out := new(GetSessionResponse)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/GetSession", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protoflowServiceClient) DeleteSession(ctx context.Context, in *DeleteSessionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/DeleteSession", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protoflowServiceClient) GetPrompts(ctx context.Context, in *GetPromptsRequest, opts ...grpc.CallOption) (*GetPromptsResponse, error) {
	out := new(GetPromptsResponse)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/GetPrompts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protoflowServiceClient) NewPrompt(ctx context.Context, in *Prompt, opts ...grpc.CallOption) (*Prompt, error) {
	out := new(Prompt)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/NewPrompt", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protoflowServiceClient) UploadContent(ctx context.Context, in *UploadContentRequest, opts ...grpc.CallOption) (ProtoflowService_UploadContentClient, error) {
	stream, err := c.cc.NewStream(ctx, &ProtoflowService_ServiceDesc.Streams[0], "/protoflow.ProtoflowService/UploadContent", opts...)
	if err != nil {
		return nil, err
	}
	x := &protoflowServiceUploadContentClient{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 ProtoflowService_UploadContentClient interface {
	Recv() (*ChatResponse, error)
	grpc.ClientStream
}

type protoflowServiceUploadContentClient struct {
	grpc.ClientStream
}

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

func (c *protoflowServiceClient) Infer(ctx context.Context, in *InferRequest, opts ...grpc.CallOption) (ProtoflowService_InferClient, error) {
	stream, err := c.cc.NewStream(ctx, &ProtoflowService_ServiceDesc.Streams[1], "/protoflow.ProtoflowService/Infer", opts...)
	if err != nil {
		return nil, err
	}
	x := &protoflowServiceInferClient{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 ProtoflowService_InferClient interface {
	Recv() (*InferResponse, error)
	grpc.ClientStream
}

type protoflowServiceInferClient struct {
	grpc.ClientStream
}

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

func (c *protoflowServiceClient) Chat(ctx context.Context, in *ChatRequest, opts ...grpc.CallOption) (ProtoflowService_ChatClient, error) {
	stream, err := c.cc.NewStream(ctx, &ProtoflowService_ServiceDesc.Streams[2], "/protoflow.ProtoflowService/Chat", opts...)
	if err != nil {
		return nil, err
	}
	x := &protoflowServiceChatClient{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 ProtoflowService_ChatClient interface {
	Recv() (*ChatResponse, error)
	grpc.ClientStream
}

type protoflowServiceChatClient struct {
	grpc.ClientStream
}

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

func (c *protoflowServiceClient) ConvertFile(ctx context.Context, in *ConvertFileRequest, opts ...grpc.CallOption) (*FilePath, error) {
	out := new(FilePath)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/ConvertFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protoflowServiceClient) GenerateImages(ctx context.Context, in *GenerateImagesRequest, opts ...grpc.CallOption) (*GenerateImagesResponse, error) {
	out := new(GenerateImagesResponse)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/GenerateImages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *protoflowServiceClient) AnalyzeConversation(ctx context.Context, in *AnalyzeConversationRequest, opts ...grpc.CallOption) (*AnalyzeConversationResponse, error) {
	out := new(AnalyzeConversationResponse)
	err := c.cc.Invoke(ctx, "/protoflow.ProtoflowService/AnalyzeConversation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProtoflowServiceServer is the server API for ProtoflowService service.
// All implementations should embed UnimplementedProtoflowServiceServer
// for forward compatibility
type ProtoflowServiceServer interface {
	DownloadYouTubeVideo(context.Context, *YouTubeVideo) (*YouTubeVideoResponse, error)
	GetSessions(context.Context, *GetSessionsRequest) (*GetSessionsResponse, error)
	GetSession(context.Context, *GetSessionRequest) (*GetSessionResponse, error)
	DeleteSession(context.Context, *DeleteSessionRequest) (*emptypb.Empty, error)
	GetPrompts(context.Context, *GetPromptsRequest) (*GetPromptsResponse, error)
	NewPrompt(context.Context, *Prompt) (*Prompt, error)
	UploadContent(*UploadContentRequest, ProtoflowService_UploadContentServer) error
	Infer(*InferRequest, ProtoflowService_InferServer) error
	Chat(*ChatRequest, ProtoflowService_ChatServer) error
	ConvertFile(context.Context, *ConvertFileRequest) (*FilePath, error)
	GenerateImages(context.Context, *GenerateImagesRequest) (*GenerateImagesResponse, error)
	AnalyzeConversation(context.Context, *AnalyzeConversationRequest) (*AnalyzeConversationResponse, error)
}

// UnimplementedProtoflowServiceServer should be embedded to have forward compatible implementations.
type UnimplementedProtoflowServiceServer struct {
}

func (UnimplementedProtoflowServiceServer) DownloadYouTubeVideo(context.Context, *YouTubeVideo) (*YouTubeVideoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DownloadYouTubeVideo not implemented")
}
func (UnimplementedProtoflowServiceServer) GetSessions(context.Context, *GetSessionsRequest) (*GetSessionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSessions not implemented")
}
func (UnimplementedProtoflowServiceServer) GetSession(context.Context, *GetSessionRequest) (*GetSessionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSession not implemented")
}
func (UnimplementedProtoflowServiceServer) DeleteSession(context.Context, *DeleteSessionRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSession not implemented")
}
func (UnimplementedProtoflowServiceServer) GetPrompts(context.Context, *GetPromptsRequest) (*GetPromptsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrompts not implemented")
}
func (UnimplementedProtoflowServiceServer) NewPrompt(context.Context, *Prompt) (*Prompt, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NewPrompt not implemented")
}
func (UnimplementedProtoflowServiceServer) UploadContent(*UploadContentRequest, ProtoflowService_UploadContentServer) error {
	return status.Errorf(codes.Unimplemented, "method UploadContent not implemented")
}
func (UnimplementedProtoflowServiceServer) Infer(*InferRequest, ProtoflowService_InferServer) error {
	return status.Errorf(codes.Unimplemented, "method Infer not implemented")
}
func (UnimplementedProtoflowServiceServer) Chat(*ChatRequest, ProtoflowService_ChatServer) error {
	return status.Errorf(codes.Unimplemented, "method Chat not implemented")
}
func (UnimplementedProtoflowServiceServer) ConvertFile(context.Context, *ConvertFileRequest) (*FilePath, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConvertFile not implemented")
}
func (UnimplementedProtoflowServiceServer) GenerateImages(context.Context, *GenerateImagesRequest) (*GenerateImagesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateImages not implemented")
}
func (UnimplementedProtoflowServiceServer) AnalyzeConversation(context.Context, *AnalyzeConversationRequest) (*AnalyzeConversationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AnalyzeConversation not implemented")
}

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

func RegisterProtoflowServiceServer(s grpc.ServiceRegistrar, srv ProtoflowServiceServer) {
	s.RegisterService(&ProtoflowService_ServiceDesc, srv)
}

func _ProtoflowService_DownloadYouTubeVideo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(YouTubeVideo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).DownloadYouTubeVideo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/DownloadYouTubeVideo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).DownloadYouTubeVideo(ctx, req.(*YouTubeVideo))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtoflowService_GetSessions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSessionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).GetSessions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/GetSessions",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).GetSessions(ctx, req.(*GetSessionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtoflowService_GetSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSessionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).GetSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/GetSession",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).GetSession(ctx, req.(*GetSessionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtoflowService_DeleteSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteSessionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).DeleteSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/DeleteSession",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).DeleteSession(ctx, req.(*DeleteSessionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtoflowService_GetPrompts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPromptsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).GetPrompts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/GetPrompts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).GetPrompts(ctx, req.(*GetPromptsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtoflowService_NewPrompt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Prompt)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).NewPrompt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/NewPrompt",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).NewPrompt(ctx, req.(*Prompt))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtoflowService_UploadContent_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UploadContentRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProtoflowServiceServer).UploadContent(m, &protoflowServiceUploadContentServer{stream})
}

type ProtoflowService_UploadContentServer interface {
	Send(*ChatResponse) error
	grpc.ServerStream
}

type protoflowServiceUploadContentServer struct {
	grpc.ServerStream
}

func (x *protoflowServiceUploadContentServer) Send(m *ChatResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ProtoflowService_Infer_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InferRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProtoflowServiceServer).Infer(m, &protoflowServiceInferServer{stream})
}

type ProtoflowService_InferServer interface {
	Send(*InferResponse) error
	grpc.ServerStream
}

type protoflowServiceInferServer struct {
	grpc.ServerStream
}

func (x *protoflowServiceInferServer) Send(m *InferResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ProtoflowService_Chat_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ChatRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProtoflowServiceServer).Chat(m, &protoflowServiceChatServer{stream})
}

type ProtoflowService_ChatServer interface {
	Send(*ChatResponse) error
	grpc.ServerStream
}

type protoflowServiceChatServer struct {
	grpc.ServerStream
}

func (x *protoflowServiceChatServer) Send(m *ChatResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ProtoflowService_ConvertFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConvertFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).ConvertFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/ConvertFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).ConvertFile(ctx, req.(*ConvertFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtoflowService_GenerateImages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateImagesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).GenerateImages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/GenerateImages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).GenerateImages(ctx, req.(*GenerateImagesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProtoflowService_AnalyzeConversation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AnalyzeConversationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProtoflowServiceServer).AnalyzeConversation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/protoflow.ProtoflowService/AnalyzeConversation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProtoflowServiceServer).AnalyzeConversation(ctx, req.(*AnalyzeConversationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ProtoflowService_ServiceDesc is the grpc.ServiceDesc for ProtoflowService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ProtoflowService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "protoflow.ProtoflowService",
	HandlerType: (*ProtoflowServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DownloadYouTubeVideo",
			Handler:    _ProtoflowService_DownloadYouTubeVideo_Handler,
		},
		{
			MethodName: "GetSessions",
			Handler:    _ProtoflowService_GetSessions_Handler,
		},
		{
			MethodName: "GetSession",
			Handler:    _ProtoflowService_GetSession_Handler,
		},
		{
			MethodName: "DeleteSession",
			Handler:    _ProtoflowService_DeleteSession_Handler,
		},
		{
			MethodName: "GetPrompts",
			Handler:    _ProtoflowService_GetPrompts_Handler,
		},
		{
			MethodName: "NewPrompt",
			Handler:    _ProtoflowService_NewPrompt_Handler,
		},
		{
			MethodName: "ConvertFile",
			Handler:    _ProtoflowService_ConvertFile_Handler,
		},
		{
			MethodName: "GenerateImages",
			Handler:    _ProtoflowService_GenerateImages_Handler,
		},
		{
			MethodName: "AnalyzeConversation",
			Handler:    _ProtoflowService_AnalyzeConversation_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "UploadContent",
			Handler:       _ProtoflowService_UploadContent_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Infer",
			Handler:       _ProtoflowService_Infer_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Chat",
			Handler:       _ProtoflowService_Chat_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "protoflow.proto",
}
