transfer_middleware/cmd/rpc/pb/transfer/transfer_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v3.6.1
// source: transfer.proto

package transfer

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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	Transfer_ZltxOrderRecharge_FullMethodName      = "/transfer.Transfer/zltxOrderRecharge"
	Transfer_ZltxOrderRechargeQuery_FullMethodName = "/transfer.Transfer/zltxOrderRechargeQuery"
	Transfer_ZltxOrderCard_FullMethodName          = "/transfer.Transfer/zltxOrderCard"
	Transfer_ZltxOrderCardQuery_FullMethodName     = "/transfer.Transfer/zltxOrderCardQuery"
	Transfer_ZltxOrderSms_FullMethodName           = "/transfer.Transfer/zltxOrderSms"
	Transfer_ZltxRechargeInfo_FullMethodName       = "/transfer.Transfer/zltxRechargeInfo"
	Transfer_ZltxRechargeProduct_FullMethodName    = "/transfer.Transfer/zltxRechargeProduct"
	Transfer_MarketKeySend_FullMethodName          = "/transfer.Transfer/marketKeySend"
	Transfer_MarketKeyDiscard_FullMethodName       = "/transfer.Transfer/marketKeyDiscard"
	Transfer_MarketQuery_FullMethodName            = "/transfer.Transfer/marketQuery"
)

// TransferClient is the client API for Transfer 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 TransferClient interface {
	ZltxOrderRecharge(ctx context.Context, in *ZltxOrderRechargeReq, opts ...grpc.CallOption) (*DefaultRes, error)
	ZltxOrderRechargeQuery(ctx context.Context, in *ZltxOrderRechargeQueryReq, opts ...grpc.CallOption) (*ZltxOrderRechargeQueryRes, error)
	ZltxOrderCard(ctx context.Context, in *ZltxOrderCardReq, opts ...grpc.CallOption) (*DefaultRes, error)
	ZltxOrderCardQuery(ctx context.Context, in *ZltxOrderCardQueryReq, opts ...grpc.CallOption) (*ZltxOrderCardQueryRes, error)
	ZltxOrderSms(ctx context.Context, in *ZltxOrderSmsReq, opts ...grpc.CallOption) (*ZltxOrderSmsRes, error)
	ZltxRechargeInfo(ctx context.Context, in *DefaultReq, opts ...grpc.CallOption) (*ZltxRechargeInfoRes, error)
	ZltxRechargeProduct(ctx context.Context, in *DefaultReq, opts ...grpc.CallOption) (*ZltxRechargeProductRes, error)
	MarketKeySend(ctx context.Context, in *MarketKeySendReq, opts ...grpc.CallOption) (*MarketKeySendRes, error)
	MarketKeyDiscard(ctx context.Context, in *MarketKeyDiscardReq, opts ...grpc.CallOption) (*MarketKeyDiscardRes, error)
	MarketQuery(ctx context.Context, in *MarketQueryReq, opts ...grpc.CallOption) (*MarketQueryRes, error)
}

type transferClient struct {
	cc grpc.ClientConnInterface
}

func NewTransferClient(cc grpc.ClientConnInterface) TransferClient {
	return &transferClient{cc}
}

func (c *transferClient) ZltxOrderRecharge(ctx context.Context, in *ZltxOrderRechargeReq, opts ...grpc.CallOption) (*DefaultRes, error) {
	out := new(DefaultRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxOrderRecharge_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) ZltxOrderRechargeQuery(ctx context.Context, in *ZltxOrderRechargeQueryReq, opts ...grpc.CallOption) (*ZltxOrderRechargeQueryRes, error) {
	out := new(ZltxOrderRechargeQueryRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxOrderRechargeQuery_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) ZltxOrderCard(ctx context.Context, in *ZltxOrderCardReq, opts ...grpc.CallOption) (*DefaultRes, error) {
	out := new(DefaultRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxOrderCard_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) ZltxOrderCardQuery(ctx context.Context, in *ZltxOrderCardQueryReq, opts ...grpc.CallOption) (*ZltxOrderCardQueryRes, error) {
	out := new(ZltxOrderCardQueryRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxOrderCardQuery_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) ZltxOrderSms(ctx context.Context, in *ZltxOrderSmsReq, opts ...grpc.CallOption) (*ZltxOrderSmsRes, error) {
	out := new(ZltxOrderSmsRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxOrderSms_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) ZltxRechargeInfo(ctx context.Context, in *DefaultReq, opts ...grpc.CallOption) (*ZltxRechargeInfoRes, error) {
	out := new(ZltxRechargeInfoRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxRechargeInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) ZltxRechargeProduct(ctx context.Context, in *DefaultReq, opts ...grpc.CallOption) (*ZltxRechargeProductRes, error) {
	out := new(ZltxRechargeProductRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxRechargeProduct_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) MarketKeySend(ctx context.Context, in *MarketKeySendReq, opts ...grpc.CallOption) (*MarketKeySendRes, error) {
	out := new(MarketKeySendRes)
	err := c.cc.Invoke(ctx, Transfer_MarketKeySend_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) MarketKeyDiscard(ctx context.Context, in *MarketKeyDiscardReq, opts ...grpc.CallOption) (*MarketKeyDiscardRes, error) {
	out := new(MarketKeyDiscardRes)
	err := c.cc.Invoke(ctx, Transfer_MarketKeyDiscard_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) MarketQuery(ctx context.Context, in *MarketQueryReq, opts ...grpc.CallOption) (*MarketQueryRes, error) {
	out := new(MarketQueryRes)
	err := c.cc.Invoke(ctx, Transfer_MarketQuery_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TransferServer is the server API for Transfer service.
// All implementations must embed UnimplementedTransferServer
// for forward compatibility
type TransferServer interface {
	ZltxOrderRecharge(context.Context, *ZltxOrderRechargeReq) (*DefaultRes, error)
	ZltxOrderRechargeQuery(context.Context, *ZltxOrderRechargeQueryReq) (*ZltxOrderRechargeQueryRes, error)
	ZltxOrderCard(context.Context, *ZltxOrderCardReq) (*DefaultRes, error)
	ZltxOrderCardQuery(context.Context, *ZltxOrderCardQueryReq) (*ZltxOrderCardQueryRes, error)
	ZltxOrderSms(context.Context, *ZltxOrderSmsReq) (*ZltxOrderSmsRes, error)
	ZltxRechargeInfo(context.Context, *DefaultReq) (*ZltxRechargeInfoRes, error)
	ZltxRechargeProduct(context.Context, *DefaultReq) (*ZltxRechargeProductRes, error)
	MarketKeySend(context.Context, *MarketKeySendReq) (*MarketKeySendRes, error)
	MarketKeyDiscard(context.Context, *MarketKeyDiscardReq) (*MarketKeyDiscardRes, error)
	MarketQuery(context.Context, *MarketQueryReq) (*MarketQueryRes, error)
	mustEmbedUnimplementedTransferServer()
}

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

func (UnimplementedTransferServer) ZltxOrderRecharge(context.Context, *ZltxOrderRechargeReq) (*DefaultRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZltxOrderRecharge not implemented")
}
func (UnimplementedTransferServer) ZltxOrderRechargeQuery(context.Context, *ZltxOrderRechargeQueryReq) (*ZltxOrderRechargeQueryRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZltxOrderRechargeQuery not implemented")
}
func (UnimplementedTransferServer) ZltxOrderCard(context.Context, *ZltxOrderCardReq) (*DefaultRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZltxOrderCard not implemented")
}
func (UnimplementedTransferServer) ZltxOrderCardQuery(context.Context, *ZltxOrderCardQueryReq) (*ZltxOrderCardQueryRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZltxOrderCardQuery not implemented")
}
func (UnimplementedTransferServer) ZltxOrderSms(context.Context, *ZltxOrderSmsReq) (*ZltxOrderSmsRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZltxOrderSms not implemented")
}
func (UnimplementedTransferServer) ZltxRechargeInfo(context.Context, *DefaultReq) (*ZltxRechargeInfoRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZltxRechargeInfo not implemented")
}
func (UnimplementedTransferServer) ZltxRechargeProduct(context.Context, *DefaultReq) (*ZltxRechargeProductRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZltxRechargeProduct not implemented")
}
func (UnimplementedTransferServer) MarketKeySend(context.Context, *MarketKeySendReq) (*MarketKeySendRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MarketKeySend not implemented")
}
func (UnimplementedTransferServer) MarketKeyDiscard(context.Context, *MarketKeyDiscardReq) (*MarketKeyDiscardRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MarketKeyDiscard not implemented")
}
func (UnimplementedTransferServer) MarketQuery(context.Context, *MarketQueryReq) (*MarketQueryRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MarketQuery not implemented")
}
func (UnimplementedTransferServer) mustEmbedUnimplementedTransferServer() {}

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

func RegisterTransferServer(s grpc.ServiceRegistrar, srv TransferServer) {
	s.RegisterService(&Transfer_ServiceDesc, srv)
}

func _Transfer_ZltxOrderRecharge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ZltxOrderRechargeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).ZltxOrderRecharge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_ZltxOrderRecharge_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).ZltxOrderRecharge(ctx, req.(*ZltxOrderRechargeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_ZltxOrderRechargeQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ZltxOrderRechargeQueryReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).ZltxOrderRechargeQuery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_ZltxOrderRechargeQuery_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).ZltxOrderRechargeQuery(ctx, req.(*ZltxOrderRechargeQueryReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_ZltxOrderCard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ZltxOrderCardReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).ZltxOrderCard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_ZltxOrderCard_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).ZltxOrderCard(ctx, req.(*ZltxOrderCardReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_ZltxOrderCardQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ZltxOrderCardQueryReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).ZltxOrderCardQuery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_ZltxOrderCardQuery_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).ZltxOrderCardQuery(ctx, req.(*ZltxOrderCardQueryReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_ZltxOrderSms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ZltxOrderSmsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).ZltxOrderSms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_ZltxOrderSms_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).ZltxOrderSms(ctx, req.(*ZltxOrderSmsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_ZltxRechargeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DefaultReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).ZltxRechargeInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_ZltxRechargeInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).ZltxRechargeInfo(ctx, req.(*DefaultReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_ZltxRechargeProduct_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DefaultReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).ZltxRechargeProduct(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_ZltxRechargeProduct_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).ZltxRechargeProduct(ctx, req.(*DefaultReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_MarketKeySend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MarketKeySendReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).MarketKeySend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_MarketKeySend_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).MarketKeySend(ctx, req.(*MarketKeySendReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_MarketKeyDiscard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MarketKeyDiscardReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).MarketKeyDiscard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_MarketKeyDiscard_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).MarketKeyDiscard(ctx, req.(*MarketKeyDiscardReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Transfer_MarketQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MarketQueryReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).MarketQuery(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_MarketQuery_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).MarketQuery(ctx, req.(*MarketQueryReq))
	}
	return interceptor(ctx, in, info, handler)
}

// Transfer_ServiceDesc is the grpc.ServiceDesc for Transfer service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Transfer_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "transfer.Transfer",
	HandlerType: (*TransferServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "zltxOrderRecharge",
			Handler:    _Transfer_ZltxOrderRecharge_Handler,
		},
		{
			MethodName: "zltxOrderRechargeQuery",
			Handler:    _Transfer_ZltxOrderRechargeQuery_Handler,
		},
		{
			MethodName: "zltxOrderCard",
			Handler:    _Transfer_ZltxOrderCard_Handler,
		},
		{
			MethodName: "zltxOrderCardQuery",
			Handler:    _Transfer_ZltxOrderCardQuery_Handler,
		},
		{
			MethodName: "zltxOrderSms",
			Handler:    _Transfer_ZltxOrderSms_Handler,
		},
		{
			MethodName: "zltxRechargeInfo",
			Handler:    _Transfer_ZltxRechargeInfo_Handler,
		},
		{
			MethodName: "zltxRechargeProduct",
			Handler:    _Transfer_ZltxRechargeProduct_Handler,
		},
		{
			MethodName: "marketKeySend",
			Handler:    _Transfer_MarketKeySend_Handler,
		},
		{
			MethodName: "marketKeyDiscard",
			Handler:    _Transfer_MarketKeyDiscard_Handler,
		},
		{
			MethodName: "marketQuery",
			Handler:    _Transfer_MarketQuery_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "transfer.proto",
}