// Copyright (c) 2024 Huawei Technologies Co., Ltd.
// openFuyao is licensed under Mulan PSL v2.
// You can use this software according to the terms and conditions of the Mulan PSL v2.
// You may obtain a copy of Mulan PSL v2 at:
//         http://license.coscl.org.cn/MulanPSL2
// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
// MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
// See the Mulan PSL v2 for more details.

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

package tokenizerv1

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.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	TokenizationService_Initialize_FullMethodName           = "/hermes.tokenizer.v1.TokenizationService/Initialize"
	TokenizationService_Tokenize_FullMethodName             = "/hermes.tokenizer.v1.TokenizationService/Tokenize"
	TokenizationService_RenderCompletion_FullMethodName     = "/hermes.tokenizer.v1.TokenizationService/RenderCompletion"
	TokenizationService_RenderChatCompletion_FullMethodName = "/hermes.tokenizer.v1.TokenizationService/RenderChatCompletion"
)

// TokenizationServiceClient is the client API for TokenizationService 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 TokenizationServiceClient interface {
	Initialize(ctx context.Context, in *InitializeRequest, opts ...grpc.CallOption) (*InitializeResponse, error)
	Tokenize(ctx context.Context, in *TokenizeRequest, opts ...grpc.CallOption) (*TokenizeResponse, error)
	RenderCompletion(ctx context.Context, in *RenderCompletionRequest, opts ...grpc.CallOption) (*RenderCompletionResponse, error)
	RenderChatCompletion(ctx context.Context, in *RenderChatCompletionRequest, opts ...grpc.CallOption) (*RenderChatCompletionResponse, error)
}

type tokenizationServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTokenizationServiceClient(cc grpc.ClientConnInterface) TokenizationServiceClient {
	return &tokenizationServiceClient{cc}
}

func (c *tokenizationServiceClient) Initialize(ctx context.Context, in *InitializeRequest, opts ...grpc.CallOption) (*InitializeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InitializeResponse)
	err := c.cc.Invoke(ctx, TokenizationService_Initialize_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tokenizationServiceClient) Tokenize(ctx context.Context, in *TokenizeRequest, opts ...grpc.CallOption) (*TokenizeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TokenizeResponse)
	err := c.cc.Invoke(ctx, TokenizationService_Tokenize_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tokenizationServiceClient) RenderCompletion(ctx context.Context, in *RenderCompletionRequest, opts ...grpc.CallOption) (*RenderCompletionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RenderCompletionResponse)
	err := c.cc.Invoke(ctx, TokenizationService_RenderCompletion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tokenizationServiceClient) RenderChatCompletion(ctx context.Context, in *RenderChatCompletionRequest, opts ...grpc.CallOption) (*RenderChatCompletionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RenderChatCompletionResponse)
	err := c.cc.Invoke(ctx, TokenizationService_RenderChatCompletion_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TokenizationServiceServer is the server API for TokenizationService service.
// All implementations must embed UnimplementedTokenizationServiceServer
// for forward compatibility.
type TokenizationServiceServer interface {
	Initialize(context.Context, *InitializeRequest) (*InitializeResponse, error)
	Tokenize(context.Context, *TokenizeRequest) (*TokenizeResponse, error)
	RenderCompletion(context.Context, *RenderCompletionRequest) (*RenderCompletionResponse, error)
	RenderChatCompletion(context.Context, *RenderChatCompletionRequest) (*RenderChatCompletionResponse, error)
	mustEmbedUnimplementedTokenizationServiceServer()
}

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

func (UnimplementedTokenizationServiceServer) Initialize(context.Context, *InitializeRequest) (*InitializeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Initialize not implemented")
}
func (UnimplementedTokenizationServiceServer) Tokenize(context.Context, *TokenizeRequest) (*TokenizeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Tokenize not implemented")
}
func (UnimplementedTokenizationServiceServer) RenderCompletion(context.Context, *RenderCompletionRequest) (*RenderCompletionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenderCompletion not implemented")
}
func (UnimplementedTokenizationServiceServer) RenderChatCompletion(context.Context, *RenderChatCompletionRequest) (*RenderChatCompletionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenderChatCompletion not implemented")
}
func (UnimplementedTokenizationServiceServer) mustEmbedUnimplementedTokenizationServiceServer() {}
func (UnimplementedTokenizationServiceServer) testEmbeddedByValue()                             {}

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

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

func _TokenizationService_Initialize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InitializeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TokenizationServiceServer).Initialize(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TokenizationService_Initialize_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TokenizationServiceServer).Initialize(ctx, req.(*InitializeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TokenizationService_Tokenize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TokenizeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TokenizationServiceServer).Tokenize(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TokenizationService_Tokenize_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TokenizationServiceServer).Tokenize(ctx, req.(*TokenizeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TokenizationService_RenderCompletion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RenderCompletionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TokenizationServiceServer).RenderCompletion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TokenizationService_RenderCompletion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TokenizationServiceServer).RenderCompletion(ctx, req.(*RenderCompletionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TokenizationService_RenderChatCompletion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RenderChatCompletionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TokenizationServiceServer).RenderChatCompletion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TokenizationService_RenderChatCompletion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TokenizationServiceServer).RenderChatCompletion(ctx, req.(*RenderChatCompletionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// TokenizationService_ServiceDesc is the grpc.ServiceDesc for TokenizationService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TokenizationService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hermes.tokenizer.v1.TokenizationService",
	HandlerType: (*TokenizationServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Initialize",
			Handler:    _TokenizationService_Initialize_Handler,
		},
		{
			MethodName: "Tokenize",
			Handler:    _TokenizationService_Tokenize_Handler,
		},
		{
			MethodName: "RenderCompletion",
			Handler:    _TokenizationService_RenderCompletion_Handler,
		},
		{
			MethodName: "RenderChatCompletion",
			Handler:    _TokenizationService_RenderChatCompletion_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api/tokenizer/v1/tokenizer.proto",
}