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

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_ZltxRsMiXue_FullMethodName                = "/transfer.Transfer/zltxRsMiXue"
	Transfer_MarketKeySend_FullMethodName              = "/transfer.Transfer/marketKeySend"
	Transfer_MarketKeyDiscard_FullMethodName           = "/transfer.Transfer/marketKeyDiscard"
	Transfer_MarketQuery_FullMethodName                = "/transfer.Transfer/marketQuery"
	Transfer_RsCouponGrant_FullMethodName              = "/transfer.Transfer/rsCouponGrant"
	Transfer_NewMarketOrder_FullMethodName             = "/transfer.Transfer/newMarketOrder"
	Transfer_NewMarketQuery_FullMethodName             = "/transfer.Transfer/newMarketQuery"
	Transfer_NewMarketDiscard_FullMethodName           = "/transfer.Transfer/newMarketDiscard"
	Transfer_PhysicalGoodsList_FullMethodName          = "/transfer.Transfer/physicalGoodsList"
	Transfer_PhysicalGoodsDetail_FullMethodName        = "/transfer.Transfer/physicalGoodsDetail"
	Transfer_PhysicalGoodsStock_FullMethodName         = "/transfer.Transfer/physicalGoodsStock"
	Transfer_PhysicalCusLogs_FullMethodName            = "/transfer.Transfer/physicalCusLogs"
	Transfer_PhysicalCusBalance_FullMethodName         = "/transfer.Transfer/physicalCusBalance"
	Transfer_PhysicalExpressList_FullMethodName        = "/transfer.Transfer/physicalExpressList"
	Transfer_PhysicalAddressList_FullMethodName        = "/transfer.Transfer/physicalAddressList"
	Transfer_PhysicalFinanceBill_FullMethodName        = "/transfer.Transfer/physicalFinanceBill"
	Transfer_PhysicalOrderInfo_FullMethodName          = "/transfer.Transfer/physicalOrderInfo"
	Transfer_PhysicalOrderList_FullMethodName          = "/transfer.Transfer/physicalOrderList"
	Transfer_PhysicalOrderSub_FullMethodName           = "/transfer.Transfer/physicalOrderSub"
	Transfer_PhysicalOrderClose_FullMethodName         = "/transfer.Transfer/physicalOrderClose"
	Transfer_PhysicalOrderLogisticsLogs_FullMethodName = "/transfer.Transfer/physicalOrderLogisticsLogs"
	Transfer_PhysicalOrderAfterApply_FullMethodName    = "/transfer.Transfer/physicalOrderAfterApply"
	Transfer_PhysicalOrderAfterReturn_FullMethodName   = "/transfer.Transfer/physicalOrderAfterReturn"
)

// 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)
	ZltxRsMiXue(ctx context.Context, in *RsCouponGrantReq, opts ...grpc.CallOption) (*RsCouponGrantRes, 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)
	RsCouponGrant(ctx context.Context, in *RsCouponGrantReq, opts ...grpc.CallOption) (*RsCouponGrantRes, error)
	NewMarketOrder(ctx context.Context, in *NewMarketOrderReq, opts ...grpc.CallOption) (*NewMarketOrderRes, error)
	NewMarketQuery(ctx context.Context, in *NewMarketQueryReq, opts ...grpc.CallOption) (*NewMarketOrderRes, error)
	NewMarketDiscard(ctx context.Context, in *NewMarketDiscardReq, opts ...grpc.CallOption) (*NewMarketDiscardRes, error)
	PhysicalGoodsList(ctx context.Context, in *PhysicalGoodsListReq, opts ...grpc.CallOption) (*PhysicalGoodsListRes, error)
	PhysicalGoodsDetail(ctx context.Context, in *PhysicalGoodsDetailReq, opts ...grpc.CallOption) (*GoodsStructWithChild, error)
	PhysicalGoodsStock(ctx context.Context, in *PhysicalGoodsStockReq, opts ...grpc.CallOption) (*PhysicalGoodsStockRes, error)
	PhysicalCusLogs(ctx context.Context, in *PhysicalCusLogsReq, opts ...grpc.CallOption) (*PhysicalCusLogsRes, error)
	PhysicalCusBalance(ctx context.Context, in *EmptyReqs, opts ...grpc.CallOption) (*PhysicalCusBalanceRes, error)
	PhysicalExpressList(ctx context.Context, in *PhysicalExpressListReq, opts ...grpc.CallOption) (*PhysicalExpressListRes, error)
	PhysicalAddressList(ctx context.Context, in *PhysicalAddressListReq, opts ...grpc.CallOption) (*PhysicalAddressListRes, error)
	PhysicalFinanceBill(ctx context.Context, in *PhysicalFinanceBillReq, opts ...grpc.CallOption) (*PhysicalFinanceBillRes, error)
	PhysicalOrderInfo(ctx context.Context, in *PhysicalOrderInfoReq, opts ...grpc.CallOption) (*PhysicalOrderInfoRes, error)
	PhysicalOrderList(ctx context.Context, in *PhysicalOrderListReq, opts ...grpc.CallOption) (*PhysicalOrderListRes, error)
	PhysicalOrderSub(ctx context.Context, in *PhysicalOrderSubReq, opts ...grpc.CallOption) (*PhysicalOrderSubRes, error)
	PhysicalOrderClose(ctx context.Context, in *PhysicalOrderCloseReq, opts ...grpc.CallOption) (*PhysicalOrderCloseRes, error)
	PhysicalOrderLogisticsLogs(ctx context.Context, in *PhysicalOrderLogisticsLogsReq, opts ...grpc.CallOption) (*PhysicalOrderLogisticsLogsRes, error)
	PhysicalOrderAfterApply(ctx context.Context, in *PhysicalOrderAfterApplyReq, opts ...grpc.CallOption) (*PhysicalOrderAfterApplyRes, error)
	PhysicalOrderAfterReturn(ctx context.Context, in *PhysicalOrderAfterReturnReq, opts ...grpc.CallOption) (*PhysicalOrderAfterReturnRes, 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) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DefaultRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxOrderRecharge_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

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

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

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

func (c *transferClient) ZltxRsMiXue(ctx context.Context, in *RsCouponGrantReq, opts ...grpc.CallOption) (*RsCouponGrantRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RsCouponGrantRes)
	err := c.cc.Invoke(ctx, Transfer_ZltxRsMiXue_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

func (c *transferClient) RsCouponGrant(ctx context.Context, in *RsCouponGrantReq, opts ...grpc.CallOption) (*RsCouponGrantRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RsCouponGrantRes)
	err := c.cc.Invoke(ctx, Transfer_RsCouponGrant_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) NewMarketOrder(ctx context.Context, in *NewMarketOrderReq, opts ...grpc.CallOption) (*NewMarketOrderRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NewMarketOrderRes)
	err := c.cc.Invoke(ctx, Transfer_NewMarketOrder_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) NewMarketQuery(ctx context.Context, in *NewMarketQueryReq, opts ...grpc.CallOption) (*NewMarketOrderRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NewMarketOrderRes)
	err := c.cc.Invoke(ctx, Transfer_NewMarketQuery_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) NewMarketDiscard(ctx context.Context, in *NewMarketDiscardReq, opts ...grpc.CallOption) (*NewMarketDiscardRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NewMarketDiscardRes)
	err := c.cc.Invoke(ctx, Transfer_NewMarketDiscard_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalGoodsList(ctx context.Context, in *PhysicalGoodsListReq, opts ...grpc.CallOption) (*PhysicalGoodsListRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalGoodsListRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalGoodsList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalGoodsDetail(ctx context.Context, in *PhysicalGoodsDetailReq, opts ...grpc.CallOption) (*GoodsStructWithChild, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GoodsStructWithChild)
	err := c.cc.Invoke(ctx, Transfer_PhysicalGoodsDetail_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalGoodsStock(ctx context.Context, in *PhysicalGoodsStockReq, opts ...grpc.CallOption) (*PhysicalGoodsStockRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalGoodsStockRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalGoodsStock_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalCusLogs(ctx context.Context, in *PhysicalCusLogsReq, opts ...grpc.CallOption) (*PhysicalCusLogsRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalCusLogsRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalCusLogs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalCusBalance(ctx context.Context, in *EmptyReqs, opts ...grpc.CallOption) (*PhysicalCusBalanceRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalCusBalanceRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalCusBalance_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalExpressList(ctx context.Context, in *PhysicalExpressListReq, opts ...grpc.CallOption) (*PhysicalExpressListRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalExpressListRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalExpressList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalAddressList(ctx context.Context, in *PhysicalAddressListReq, opts ...grpc.CallOption) (*PhysicalAddressListRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalAddressListRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalAddressList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalFinanceBill(ctx context.Context, in *PhysicalFinanceBillReq, opts ...grpc.CallOption) (*PhysicalFinanceBillRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalFinanceBillRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalFinanceBill_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalOrderInfo(ctx context.Context, in *PhysicalOrderInfoReq, opts ...grpc.CallOption) (*PhysicalOrderInfoRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalOrderInfoRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalOrderInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalOrderList(ctx context.Context, in *PhysicalOrderListReq, opts ...grpc.CallOption) (*PhysicalOrderListRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalOrderListRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalOrderList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalOrderSub(ctx context.Context, in *PhysicalOrderSubReq, opts ...grpc.CallOption) (*PhysicalOrderSubRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalOrderSubRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalOrderSub_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalOrderClose(ctx context.Context, in *PhysicalOrderCloseReq, opts ...grpc.CallOption) (*PhysicalOrderCloseRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalOrderCloseRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalOrderClose_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalOrderLogisticsLogs(ctx context.Context, in *PhysicalOrderLogisticsLogsReq, opts ...grpc.CallOption) (*PhysicalOrderLogisticsLogsRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalOrderLogisticsLogsRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalOrderLogisticsLogs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalOrderAfterApply(ctx context.Context, in *PhysicalOrderAfterApplyReq, opts ...grpc.CallOption) (*PhysicalOrderAfterApplyRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalOrderAfterApplyRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalOrderAfterApply_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *transferClient) PhysicalOrderAfterReturn(ctx context.Context, in *PhysicalOrderAfterReturnReq, opts ...grpc.CallOption) (*PhysicalOrderAfterReturnRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PhysicalOrderAfterReturnRes)
	err := c.cc.Invoke(ctx, Transfer_PhysicalOrderAfterReturn_FullMethodName, in, out, cOpts...)
	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)
	ZltxRsMiXue(context.Context, *RsCouponGrantReq) (*RsCouponGrantRes, error)
	MarketKeySend(context.Context, *MarketKeySendReq) (*MarketKeySendRes, error)
	MarketKeyDiscard(context.Context, *MarketKeyDiscardReq) (*MarketKeyDiscardRes, error)
	MarketQuery(context.Context, *MarketQueryReq) (*MarketQueryRes, error)
	RsCouponGrant(context.Context, *RsCouponGrantReq) (*RsCouponGrantRes, error)
	NewMarketOrder(context.Context, *NewMarketOrderReq) (*NewMarketOrderRes, error)
	NewMarketQuery(context.Context, *NewMarketQueryReq) (*NewMarketOrderRes, error)
	NewMarketDiscard(context.Context, *NewMarketDiscardReq) (*NewMarketDiscardRes, error)
	PhysicalGoodsList(context.Context, *PhysicalGoodsListReq) (*PhysicalGoodsListRes, error)
	PhysicalGoodsDetail(context.Context, *PhysicalGoodsDetailReq) (*GoodsStructWithChild, error)
	PhysicalGoodsStock(context.Context, *PhysicalGoodsStockReq) (*PhysicalGoodsStockRes, error)
	PhysicalCusLogs(context.Context, *PhysicalCusLogsReq) (*PhysicalCusLogsRes, error)
	PhysicalCusBalance(context.Context, *EmptyReqs) (*PhysicalCusBalanceRes, error)
	PhysicalExpressList(context.Context, *PhysicalExpressListReq) (*PhysicalExpressListRes, error)
	PhysicalAddressList(context.Context, *PhysicalAddressListReq) (*PhysicalAddressListRes, error)
	PhysicalFinanceBill(context.Context, *PhysicalFinanceBillReq) (*PhysicalFinanceBillRes, error)
	PhysicalOrderInfo(context.Context, *PhysicalOrderInfoReq) (*PhysicalOrderInfoRes, error)
	PhysicalOrderList(context.Context, *PhysicalOrderListReq) (*PhysicalOrderListRes, error)
	PhysicalOrderSub(context.Context, *PhysicalOrderSubReq) (*PhysicalOrderSubRes, error)
	PhysicalOrderClose(context.Context, *PhysicalOrderCloseReq) (*PhysicalOrderCloseRes, error)
	PhysicalOrderLogisticsLogs(context.Context, *PhysicalOrderLogisticsLogsReq) (*PhysicalOrderLogisticsLogsRes, error)
	PhysicalOrderAfterApply(context.Context, *PhysicalOrderAfterApplyReq) (*PhysicalOrderAfterApplyRes, error)
	PhysicalOrderAfterReturn(context.Context, *PhysicalOrderAfterReturnReq) (*PhysicalOrderAfterReturnRes, error)
	mustEmbedUnimplementedTransferServer()
}

// UnimplementedTransferServer 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 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) ZltxRsMiXue(context.Context, *RsCouponGrantReq) (*RsCouponGrantRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZltxRsMiXue 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) RsCouponGrant(context.Context, *RsCouponGrantReq) (*RsCouponGrantRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RsCouponGrant not implemented")
}
func (UnimplementedTransferServer) NewMarketOrder(context.Context, *NewMarketOrderReq) (*NewMarketOrderRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NewMarketOrder not implemented")
}
func (UnimplementedTransferServer) NewMarketQuery(context.Context, *NewMarketQueryReq) (*NewMarketOrderRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NewMarketQuery not implemented")
}
func (UnimplementedTransferServer) NewMarketDiscard(context.Context, *NewMarketDiscardReq) (*NewMarketDiscardRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NewMarketDiscard not implemented")
}
func (UnimplementedTransferServer) PhysicalGoodsList(context.Context, *PhysicalGoodsListReq) (*PhysicalGoodsListRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalGoodsList not implemented")
}
func (UnimplementedTransferServer) PhysicalGoodsDetail(context.Context, *PhysicalGoodsDetailReq) (*GoodsStructWithChild, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalGoodsDetail not implemented")
}
func (UnimplementedTransferServer) PhysicalGoodsStock(context.Context, *PhysicalGoodsStockReq) (*PhysicalGoodsStockRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalGoodsStock not implemented")
}
func (UnimplementedTransferServer) PhysicalCusLogs(context.Context, *PhysicalCusLogsReq) (*PhysicalCusLogsRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalCusLogs not implemented")
}
func (UnimplementedTransferServer) PhysicalCusBalance(context.Context, *EmptyReqs) (*PhysicalCusBalanceRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalCusBalance not implemented")
}
func (UnimplementedTransferServer) PhysicalExpressList(context.Context, *PhysicalExpressListReq) (*PhysicalExpressListRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalExpressList not implemented")
}
func (UnimplementedTransferServer) PhysicalAddressList(context.Context, *PhysicalAddressListReq) (*PhysicalAddressListRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalAddressList not implemented")
}
func (UnimplementedTransferServer) PhysicalFinanceBill(context.Context, *PhysicalFinanceBillReq) (*PhysicalFinanceBillRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalFinanceBill not implemented")
}
func (UnimplementedTransferServer) PhysicalOrderInfo(context.Context, *PhysicalOrderInfoReq) (*PhysicalOrderInfoRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalOrderInfo not implemented")
}
func (UnimplementedTransferServer) PhysicalOrderList(context.Context, *PhysicalOrderListReq) (*PhysicalOrderListRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalOrderList not implemented")
}
func (UnimplementedTransferServer) PhysicalOrderSub(context.Context, *PhysicalOrderSubReq) (*PhysicalOrderSubRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalOrderSub not implemented")
}
func (UnimplementedTransferServer) PhysicalOrderClose(context.Context, *PhysicalOrderCloseReq) (*PhysicalOrderCloseRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalOrderClose not implemented")
}
func (UnimplementedTransferServer) PhysicalOrderLogisticsLogs(context.Context, *PhysicalOrderLogisticsLogsReq) (*PhysicalOrderLogisticsLogsRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalOrderLogisticsLogs not implemented")
}
func (UnimplementedTransferServer) PhysicalOrderAfterApply(context.Context, *PhysicalOrderAfterApplyReq) (*PhysicalOrderAfterApplyRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalOrderAfterApply not implemented")
}
func (UnimplementedTransferServer) PhysicalOrderAfterReturn(context.Context, *PhysicalOrderAfterReturnReq) (*PhysicalOrderAfterReturnRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PhysicalOrderAfterReturn not implemented")
}
func (UnimplementedTransferServer) mustEmbedUnimplementedTransferServer() {}
func (UnimplementedTransferServer) testEmbeddedByValue()                  {}

// 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) {
	// If the following call pancis, it indicates UnimplementedTransferServer 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(&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_ZltxRsMiXue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RsCouponGrantReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).ZltxRsMiXue(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_ZltxRsMiXue_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).ZltxRsMiXue(ctx, req.(*RsCouponGrantReq))
	}
	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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func _Transfer_PhysicalOrderAfterReturn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PhysicalOrderAfterReturnReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TransferServer).PhysicalOrderAfterReturn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Transfer_PhysicalOrderAfterReturn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TransferServer).PhysicalOrderAfterReturn(ctx, req.(*PhysicalOrderAfterReturnReq))
	}
	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: "zltxRsMiXue",
			Handler:    _Transfer_ZltxRsMiXue_Handler,
		},
		{
			MethodName: "marketKeySend",
			Handler:    _Transfer_MarketKeySend_Handler,
		},
		{
			MethodName: "marketKeyDiscard",
			Handler:    _Transfer_MarketKeyDiscard_Handler,
		},
		{
			MethodName: "marketQuery",
			Handler:    _Transfer_MarketQuery_Handler,
		},
		{
			MethodName: "rsCouponGrant",
			Handler:    _Transfer_RsCouponGrant_Handler,
		},
		{
			MethodName: "newMarketOrder",
			Handler:    _Transfer_NewMarketOrder_Handler,
		},
		{
			MethodName: "newMarketQuery",
			Handler:    _Transfer_NewMarketQuery_Handler,
		},
		{
			MethodName: "newMarketDiscard",
			Handler:    _Transfer_NewMarketDiscard_Handler,
		},
		{
			MethodName: "physicalGoodsList",
			Handler:    _Transfer_PhysicalGoodsList_Handler,
		},
		{
			MethodName: "physicalGoodsDetail",
			Handler:    _Transfer_PhysicalGoodsDetail_Handler,
		},
		{
			MethodName: "physicalGoodsStock",
			Handler:    _Transfer_PhysicalGoodsStock_Handler,
		},
		{
			MethodName: "physicalCusLogs",
			Handler:    _Transfer_PhysicalCusLogs_Handler,
		},
		{
			MethodName: "physicalCusBalance",
			Handler:    _Transfer_PhysicalCusBalance_Handler,
		},
		{
			MethodName: "physicalExpressList",
			Handler:    _Transfer_PhysicalExpressList_Handler,
		},
		{
			MethodName: "physicalAddressList",
			Handler:    _Transfer_PhysicalAddressList_Handler,
		},
		{
			MethodName: "physicalFinanceBill",
			Handler:    _Transfer_PhysicalFinanceBill_Handler,
		},
		{
			MethodName: "physicalOrderInfo",
			Handler:    _Transfer_PhysicalOrderInfo_Handler,
		},
		{
			MethodName: "physicalOrderList",
			Handler:    _Transfer_PhysicalOrderList_Handler,
		},
		{
			MethodName: "physicalOrderSub",
			Handler:    _Transfer_PhysicalOrderSub_Handler,
		},
		{
			MethodName: "physicalOrderClose",
			Handler:    _Transfer_PhysicalOrderClose_Handler,
		},
		{
			MethodName: "physicalOrderLogisticsLogs",
			Handler:    _Transfer_PhysicalOrderLogisticsLogs_Handler,
		},
		{
			MethodName: "physicalOrderAfterApply",
			Handler:    _Transfer_PhysicalOrderAfterApply_Handler,
		},
		{
			MethodName: "physicalOrderAfterReturn",
			Handler:    _Transfer_PhysicalOrderAfterReturn_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "transfer.proto",
}