package com.ywt.gapi.ordercenter;

import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;

/**
 * <pre>
 *订单中心服务  // 对应 rpc-ordercenter-service 项目的 OrderCenterServiceImpl 类
 * </pre>
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.7.2-SNAPSHOT)",
    comments = "Source: ordercenter.proto")
public final class OrderCenterServiceGrpc {

  private OrderCenterServiceGrpc() {}

  public static final String SERVICE_NAME = "com.ywt.gapi.ordercenter.OrderCenterService";

  // Static method descriptors that strictly reflect the proto.
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.CreateOrderRequest,
      com.ywt.gapi.ordercenter.CreateOrderResponse> METHOD_CREATE_ORDER =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.CreateOrderRequest, com.ywt.gapi.ordercenter.CreateOrderResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "createOrder"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.CreateOrderRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.CreateOrderResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("createOrder"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.PayByAdminRequest,
      com.ywt.gapi.ordercenter.PayByAdminResponse> METHOD_PAY_BY_ADMIN =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.PayByAdminRequest, com.ywt.gapi.ordercenter.PayByAdminResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "payByAdmin"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.PayByAdminRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.PayByAdminResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("payByAdmin"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.WechatPaymentRequest,
      com.ywt.gapi.ordercenter.WechatPaymentResponse> METHOD_WECHAT_PAYMENT =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.WechatPaymentRequest, com.ywt.gapi.ordercenter.WechatPaymentResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "wechatPayment"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.WechatPaymentRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.WechatPaymentResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("wechatPayment"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest,
      com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse> METHOD_WECHAT_PAYMENT_NOTIFY =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest, com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "WechatPaymentNotify"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("WechatPaymentNotify"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.GetOrderInfoRequest,
      com.ywt.gapi.ordercenter.GetOrderInfeResponse> METHOD_GET_ORDER_INFO =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.GetOrderInfoRequest, com.ywt.gapi.ordercenter.GetOrderInfeResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "getOrderInfo"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.GetOrderInfoRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.GetOrderInfeResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("getOrderInfo"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.UpdateOrderInfoRequest,
      com.ywt.gapi.ordercenter.UpdateOrderInfoResponse> METHOD_UPDATE_ORDER_INFO =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.UpdateOrderInfoRequest, com.ywt.gapi.ordercenter.UpdateOrderInfoResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "updateOrderInfo"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.UpdateOrderInfoRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.UpdateOrderInfoResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("updateOrderInfo"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.RefundRequest,
      com.ywt.gapi.ordercenter.RefundResponse> METHOD_REFUND =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.RefundRequest, com.ywt.gapi.ordercenter.RefundResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "refund"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.RefundRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.RefundResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("refund"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.WechatRefundNotifyRequest,
      com.ywt.gapi.ordercenter.WechatRefundNotifyResponse> METHOD_WECHAT_REFUND_NOTIFY =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.WechatRefundNotifyRequest, com.ywt.gapi.ordercenter.WechatRefundNotifyResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "wechatRefundNotify"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.WechatRefundNotifyRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.WechatRefundNotifyResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("wechatRefundNotify"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.GetOrderBillRequest,
      com.ywt.gapi.ordercenter.GetOrderBillResponse> METHOD_GET_ORDER_BILL =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.GetOrderBillRequest, com.ywt.gapi.ordercenter.GetOrderBillResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "getOrderBill"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.GetOrderBillRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.GetOrderBillResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("getOrderBill"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.PrePayByPOSRequest,
      com.ywt.gapi.ordercenter.PrePayByPOSResponse> METHOD_PRE_PAY_BY_POS =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.PrePayByPOSRequest, com.ywt.gapi.ordercenter.PrePayByPOSResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "prePayByPOS"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.PrePayByPOSRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.PrePayByPOSResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("prePayByPOS"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.FinishPayByPOSRequest,
      com.ywt.gapi.ordercenter.FinishPayByPOSResponse> METHOD_FINISH_PAY_BY_POS =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.FinishPayByPOSRequest, com.ywt.gapi.ordercenter.FinishPayByPOSResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "finishPayByPOS"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.FinishPayByPOSRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.FinishPayByPOSResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("finishPayByPOS"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.ICBCPaymentRequest,
      com.ywt.gapi.ordercenter.ICBCPaymentResponse> METHOD_ICBC_PAYMENT =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.ICBCPaymentRequest, com.ywt.gapi.ordercenter.ICBCPaymentResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "icbcPayment"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.ICBCPaymentRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.ICBCPaymentResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("icbcPayment"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest,
      com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse> METHOD_ICBC_PAYMENT_NOTIFY =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest, com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "icbcPaymentNotify"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("icbcPaymentNotify"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest,
      com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse> METHOD_ICBC_REFUND_NOTIFY =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest, com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "icbcRefundNotify"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("icbcRefundNotify"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.CleanPayLockRequest,
      com.ywt.gapi.ordercenter.CleanPayLockResponse> METHOD_CLEAN_PAY_LOCK =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.CleanPayLockRequest, com.ywt.gapi.ordercenter.CleanPayLockResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "cleanPayLock"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.CleanPayLockRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.CleanPayLockResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("cleanPayLock"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.ordercenter.CheckIsPayingRequest,
      com.ywt.gapi.ordercenter.CheckIsPayingResponse> METHOD_CHECK_IS_PAYING =
      io.grpc.MethodDescriptor.<com.ywt.gapi.ordercenter.CheckIsPayingRequest, com.ywt.gapi.ordercenter.CheckIsPayingResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.ordercenter.OrderCenterService", "checkIsPaying"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.CheckIsPayingRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.ordercenter.CheckIsPayingResponse.getDefaultInstance()))
          .setSchemaDescriptor(new OrderCenterServiceMethodDescriptorSupplier("checkIsPaying"))
          .build();

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static OrderCenterServiceStub newStub(io.grpc.Channel channel) {
    return new OrderCenterServiceStub(channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static OrderCenterServiceBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    return new OrderCenterServiceBlockingStub(channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static OrderCenterServiceFutureStub newFutureStub(
      io.grpc.Channel channel) {
    return new OrderCenterServiceFutureStub(channel);
  }

  /**
   * <pre>
   *订单中心服务  // 对应 rpc-ordercenter-service 项目的 OrderCenterServiceImpl 类
   * </pre>
   */
  public static abstract class OrderCenterServiceImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     *创建订单
     * </pre>
     */
    public void createOrder(com.ywt.gapi.ordercenter.CreateOrderRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CreateOrderResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_CREATE_ORDER, responseObserver);
    }

    /**
     * <pre>
     *管理员线下收费
     * </pre>
     */
    public void payByAdmin(com.ywt.gapi.ordercenter.PayByAdminRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.PayByAdminResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_PAY_BY_ADMIN, responseObserver);
    }

    /**
     * <pre>
     *微信支付方式支付订单
     * </pre>
     */
    public void wechatPayment(com.ywt.gapi.ordercenter.WechatPaymentRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatPaymentResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_WECHAT_PAYMENT, responseObserver);
    }

    /**
     * <pre>
     *支付中心微信支付成功后回调通知
     * </pre>
     */
    public void wechatPaymentNotify(com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_WECHAT_PAYMENT_NOTIFY, responseObserver);
    }

    /**
     * <pre>
     *获取订单信息
     * </pre>
     */
    public void getOrderInfo(com.ywt.gapi.ordercenter.GetOrderInfoRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.GetOrderInfeResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_ORDER_INFO, responseObserver);
    }

    /**
     * <pre>
     *更新订单信息
     * </pre>
     */
    public void updateOrderInfo(com.ywt.gapi.ordercenter.UpdateOrderInfoRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.UpdateOrderInfoResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_UPDATE_ORDER_INFO, responseObserver);
    }

    /**
     * <pre>
     *退款
     * </pre>
     */
    public void refund(com.ywt.gapi.ordercenter.RefundRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.RefundResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_REFUND, responseObserver);
    }

    /**
     * <pre>
     *支付中心微信退款成功通知
     * </pre>
     */
    public void wechatRefundNotify(com.ywt.gapi.ordercenter.WechatRefundNotifyRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatRefundNotifyResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_WECHAT_REFUND_NOTIFY, responseObserver);
    }

    /**
     * <pre>
     *获取订单中心账单
     * </pre>
     */
    public void getOrderBill(com.ywt.gapi.ordercenter.GetOrderBillRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.GetOrderBillResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_ORDER_BILL, responseObserver);
    }

    /**
     * <pre>
     *POS机申请预支付信息
     * </pre>
     */
    public void prePayByPOS(com.ywt.gapi.ordercenter.PrePayByPOSRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.PrePayByPOSResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_PRE_PAY_BY_POS, responseObserver);
    }

    /**
     * <pre>
     *POS机完成支付信息更新
     * </pre>
     */
    public void finishPayByPOS(com.ywt.gapi.ordercenter.FinishPayByPOSRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.FinishPayByPOSResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_FINISH_PAY_BY_POS, responseObserver);
    }

    /**
     * <pre>
     *ICBC支付方式支付订单
     * </pre>
     */
    public void icbcPayment(com.ywt.gapi.ordercenter.ICBCPaymentRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCPaymentResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_ICBC_PAYMENT, responseObserver);
    }

    /**
     * <pre>
     *支付中心ICBC支付成功后回调通知
     * </pre>
     */
    public void icbcPaymentNotify(com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_ICBC_PAYMENT_NOTIFY, responseObserver);
    }

    /**
     * <pre>
     *支付中心工行退款成功通知
     * </pre>
     */
    public void icbcRefundNotify(com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_ICBC_REFUND_NOTIFY, responseObserver);
    }

    /**
     * <pre>
     *清除支付锁
     * </pre>
     */
    public void cleanPayLock(com.ywt.gapi.ordercenter.CleanPayLockRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CleanPayLockResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_CLEAN_PAY_LOCK, responseObserver);
    }

    /**
     * <pre>
     *判断是否在支付中
     * </pre>
     */
    public void checkIsPaying(com.ywt.gapi.ordercenter.CheckIsPayingRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CheckIsPayingResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_CHECK_IS_PAYING, responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            METHOD_CREATE_ORDER,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.CreateOrderRequest,
                com.ywt.gapi.ordercenter.CreateOrderResponse>(
                  this, METHODID_CREATE_ORDER)))
          .addMethod(
            METHOD_PAY_BY_ADMIN,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.PayByAdminRequest,
                com.ywt.gapi.ordercenter.PayByAdminResponse>(
                  this, METHODID_PAY_BY_ADMIN)))
          .addMethod(
            METHOD_WECHAT_PAYMENT,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.WechatPaymentRequest,
                com.ywt.gapi.ordercenter.WechatPaymentResponse>(
                  this, METHODID_WECHAT_PAYMENT)))
          .addMethod(
            METHOD_WECHAT_PAYMENT_NOTIFY,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest,
                com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse>(
                  this, METHODID_WECHAT_PAYMENT_NOTIFY)))
          .addMethod(
            METHOD_GET_ORDER_INFO,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.GetOrderInfoRequest,
                com.ywt.gapi.ordercenter.GetOrderInfeResponse>(
                  this, METHODID_GET_ORDER_INFO)))
          .addMethod(
            METHOD_UPDATE_ORDER_INFO,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.UpdateOrderInfoRequest,
                com.ywt.gapi.ordercenter.UpdateOrderInfoResponse>(
                  this, METHODID_UPDATE_ORDER_INFO)))
          .addMethod(
            METHOD_REFUND,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.RefundRequest,
                com.ywt.gapi.ordercenter.RefundResponse>(
                  this, METHODID_REFUND)))
          .addMethod(
            METHOD_WECHAT_REFUND_NOTIFY,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.WechatRefundNotifyRequest,
                com.ywt.gapi.ordercenter.WechatRefundNotifyResponse>(
                  this, METHODID_WECHAT_REFUND_NOTIFY)))
          .addMethod(
            METHOD_GET_ORDER_BILL,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.GetOrderBillRequest,
                com.ywt.gapi.ordercenter.GetOrderBillResponse>(
                  this, METHODID_GET_ORDER_BILL)))
          .addMethod(
            METHOD_PRE_PAY_BY_POS,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.PrePayByPOSRequest,
                com.ywt.gapi.ordercenter.PrePayByPOSResponse>(
                  this, METHODID_PRE_PAY_BY_POS)))
          .addMethod(
            METHOD_FINISH_PAY_BY_POS,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.FinishPayByPOSRequest,
                com.ywt.gapi.ordercenter.FinishPayByPOSResponse>(
                  this, METHODID_FINISH_PAY_BY_POS)))
          .addMethod(
            METHOD_ICBC_PAYMENT,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.ICBCPaymentRequest,
                com.ywt.gapi.ordercenter.ICBCPaymentResponse>(
                  this, METHODID_ICBC_PAYMENT)))
          .addMethod(
            METHOD_ICBC_PAYMENT_NOTIFY,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest,
                com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse>(
                  this, METHODID_ICBC_PAYMENT_NOTIFY)))
          .addMethod(
            METHOD_ICBC_REFUND_NOTIFY,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest,
                com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse>(
                  this, METHODID_ICBC_REFUND_NOTIFY)))
          .addMethod(
            METHOD_CLEAN_PAY_LOCK,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.CleanPayLockRequest,
                com.ywt.gapi.ordercenter.CleanPayLockResponse>(
                  this, METHODID_CLEAN_PAY_LOCK)))
          .addMethod(
            METHOD_CHECK_IS_PAYING,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.ordercenter.CheckIsPayingRequest,
                com.ywt.gapi.ordercenter.CheckIsPayingResponse>(
                  this, METHODID_CHECK_IS_PAYING)))
          .build();
    }
  }

  /**
   * <pre>
   *订单中心服务  // 对应 rpc-ordercenter-service 项目的 OrderCenterServiceImpl 类
   * </pre>
   */
  public static final class OrderCenterServiceStub extends io.grpc.stub.AbstractStub<OrderCenterServiceStub> {
    private OrderCenterServiceStub(io.grpc.Channel channel) {
      super(channel);
    }

    private OrderCenterServiceStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected OrderCenterServiceStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new OrderCenterServiceStub(channel, callOptions);
    }

    /**
     * <pre>
     *创建订单
     * </pre>
     */
    public void createOrder(com.ywt.gapi.ordercenter.CreateOrderRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CreateOrderResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_CREATE_ORDER, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *管理员线下收费
     * </pre>
     */
    public void payByAdmin(com.ywt.gapi.ordercenter.PayByAdminRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.PayByAdminResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_PAY_BY_ADMIN, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *微信支付方式支付订单
     * </pre>
     */
    public void wechatPayment(com.ywt.gapi.ordercenter.WechatPaymentRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatPaymentResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_WECHAT_PAYMENT, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *支付中心微信支付成功后回调通知
     * </pre>
     */
    public void wechatPaymentNotify(com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_WECHAT_PAYMENT_NOTIFY, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *获取订单信息
     * </pre>
     */
    public void getOrderInfo(com.ywt.gapi.ordercenter.GetOrderInfoRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.GetOrderInfeResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_ORDER_INFO, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *更新订单信息
     * </pre>
     */
    public void updateOrderInfo(com.ywt.gapi.ordercenter.UpdateOrderInfoRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.UpdateOrderInfoResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_UPDATE_ORDER_INFO, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *退款
     * </pre>
     */
    public void refund(com.ywt.gapi.ordercenter.RefundRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.RefundResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_REFUND, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *支付中心微信退款成功通知
     * </pre>
     */
    public void wechatRefundNotify(com.ywt.gapi.ordercenter.WechatRefundNotifyRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatRefundNotifyResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_WECHAT_REFUND_NOTIFY, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *获取订单中心账单
     * </pre>
     */
    public void getOrderBill(com.ywt.gapi.ordercenter.GetOrderBillRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.GetOrderBillResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_ORDER_BILL, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *POS机申请预支付信息
     * </pre>
     */
    public void prePayByPOS(com.ywt.gapi.ordercenter.PrePayByPOSRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.PrePayByPOSResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_PRE_PAY_BY_POS, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *POS机完成支付信息更新
     * </pre>
     */
    public void finishPayByPOS(com.ywt.gapi.ordercenter.FinishPayByPOSRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.FinishPayByPOSResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_FINISH_PAY_BY_POS, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *ICBC支付方式支付订单
     * </pre>
     */
    public void icbcPayment(com.ywt.gapi.ordercenter.ICBCPaymentRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCPaymentResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_ICBC_PAYMENT, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *支付中心ICBC支付成功后回调通知
     * </pre>
     */
    public void icbcPaymentNotify(com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_ICBC_PAYMENT_NOTIFY, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *支付中心工行退款成功通知
     * </pre>
     */
    public void icbcRefundNotify(com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_ICBC_REFUND_NOTIFY, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *清除支付锁
     * </pre>
     */
    public void cleanPayLock(com.ywt.gapi.ordercenter.CleanPayLockRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CleanPayLockResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_CLEAN_PAY_LOCK, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *判断是否在支付中
     * </pre>
     */
    public void checkIsPaying(com.ywt.gapi.ordercenter.CheckIsPayingRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CheckIsPayingResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_CHECK_IS_PAYING, getCallOptions()), request, responseObserver);
    }
  }

  /**
   * <pre>
   *订单中心服务  // 对应 rpc-ordercenter-service 项目的 OrderCenterServiceImpl 类
   * </pre>
   */
  public static final class OrderCenterServiceBlockingStub extends io.grpc.stub.AbstractStub<OrderCenterServiceBlockingStub> {
    private OrderCenterServiceBlockingStub(io.grpc.Channel channel) {
      super(channel);
    }

    private OrderCenterServiceBlockingStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected OrderCenterServiceBlockingStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new OrderCenterServiceBlockingStub(channel, callOptions);
    }

    /**
     * <pre>
     *创建订单
     * </pre>
     */
    public com.ywt.gapi.ordercenter.CreateOrderResponse createOrder(com.ywt.gapi.ordercenter.CreateOrderRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_CREATE_ORDER, getCallOptions(), request);
    }

    /**
     * <pre>
     *管理员线下收费
     * </pre>
     */
    public com.ywt.gapi.ordercenter.PayByAdminResponse payByAdmin(com.ywt.gapi.ordercenter.PayByAdminRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_PAY_BY_ADMIN, getCallOptions(), request);
    }

    /**
     * <pre>
     *微信支付方式支付订单
     * </pre>
     */
    public com.ywt.gapi.ordercenter.WechatPaymentResponse wechatPayment(com.ywt.gapi.ordercenter.WechatPaymentRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_WECHAT_PAYMENT, getCallOptions(), request);
    }

    /**
     * <pre>
     *支付中心微信支付成功后回调通知
     * </pre>
     */
    public com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse wechatPaymentNotify(com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_WECHAT_PAYMENT_NOTIFY, getCallOptions(), request);
    }

    /**
     * <pre>
     *获取订单信息
     * </pre>
     */
    public com.ywt.gapi.ordercenter.GetOrderInfeResponse getOrderInfo(com.ywt.gapi.ordercenter.GetOrderInfoRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_ORDER_INFO, getCallOptions(), request);
    }

    /**
     * <pre>
     *更新订单信息
     * </pre>
     */
    public com.ywt.gapi.ordercenter.UpdateOrderInfoResponse updateOrderInfo(com.ywt.gapi.ordercenter.UpdateOrderInfoRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_UPDATE_ORDER_INFO, getCallOptions(), request);
    }

    /**
     * <pre>
     *退款
     * </pre>
     */
    public com.ywt.gapi.ordercenter.RefundResponse refund(com.ywt.gapi.ordercenter.RefundRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_REFUND, getCallOptions(), request);
    }

    /**
     * <pre>
     *支付中心微信退款成功通知
     * </pre>
     */
    public com.ywt.gapi.ordercenter.WechatRefundNotifyResponse wechatRefundNotify(com.ywt.gapi.ordercenter.WechatRefundNotifyRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_WECHAT_REFUND_NOTIFY, getCallOptions(), request);
    }

    /**
     * <pre>
     *获取订单中心账单
     * </pre>
     */
    public com.ywt.gapi.ordercenter.GetOrderBillResponse getOrderBill(com.ywt.gapi.ordercenter.GetOrderBillRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_ORDER_BILL, getCallOptions(), request);
    }

    /**
     * <pre>
     *POS机申请预支付信息
     * </pre>
     */
    public com.ywt.gapi.ordercenter.PrePayByPOSResponse prePayByPOS(com.ywt.gapi.ordercenter.PrePayByPOSRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_PRE_PAY_BY_POS, getCallOptions(), request);
    }

    /**
     * <pre>
     *POS机完成支付信息更新
     * </pre>
     */
    public com.ywt.gapi.ordercenter.FinishPayByPOSResponse finishPayByPOS(com.ywt.gapi.ordercenter.FinishPayByPOSRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_FINISH_PAY_BY_POS, getCallOptions(), request);
    }

    /**
     * <pre>
     *ICBC支付方式支付订单
     * </pre>
     */
    public com.ywt.gapi.ordercenter.ICBCPaymentResponse icbcPayment(com.ywt.gapi.ordercenter.ICBCPaymentRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_ICBC_PAYMENT, getCallOptions(), request);
    }

    /**
     * <pre>
     *支付中心ICBC支付成功后回调通知
     * </pre>
     */
    public com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse icbcPaymentNotify(com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_ICBC_PAYMENT_NOTIFY, getCallOptions(), request);
    }

    /**
     * <pre>
     *支付中心工行退款成功通知
     * </pre>
     */
    public com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse icbcRefundNotify(com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_ICBC_REFUND_NOTIFY, getCallOptions(), request);
    }

    /**
     * <pre>
     *清除支付锁
     * </pre>
     */
    public com.ywt.gapi.ordercenter.CleanPayLockResponse cleanPayLock(com.ywt.gapi.ordercenter.CleanPayLockRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_CLEAN_PAY_LOCK, getCallOptions(), request);
    }

    /**
     * <pre>
     *判断是否在支付中
     * </pre>
     */
    public com.ywt.gapi.ordercenter.CheckIsPayingResponse checkIsPaying(com.ywt.gapi.ordercenter.CheckIsPayingRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_CHECK_IS_PAYING, getCallOptions(), request);
    }
  }

  /**
   * <pre>
   *订单中心服务  // 对应 rpc-ordercenter-service 项目的 OrderCenterServiceImpl 类
   * </pre>
   */
  public static final class OrderCenterServiceFutureStub extends io.grpc.stub.AbstractStub<OrderCenterServiceFutureStub> {
    private OrderCenterServiceFutureStub(io.grpc.Channel channel) {
      super(channel);
    }

    private OrderCenterServiceFutureStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected OrderCenterServiceFutureStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new OrderCenterServiceFutureStub(channel, callOptions);
    }

    /**
     * <pre>
     *创建订单
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.CreateOrderResponse> createOrder(
        com.ywt.gapi.ordercenter.CreateOrderRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_CREATE_ORDER, getCallOptions()), request);
    }

    /**
     * <pre>
     *管理员线下收费
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.PayByAdminResponse> payByAdmin(
        com.ywt.gapi.ordercenter.PayByAdminRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_PAY_BY_ADMIN, getCallOptions()), request);
    }

    /**
     * <pre>
     *微信支付方式支付订单
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.WechatPaymentResponse> wechatPayment(
        com.ywt.gapi.ordercenter.WechatPaymentRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_WECHAT_PAYMENT, getCallOptions()), request);
    }

    /**
     * <pre>
     *支付中心微信支付成功后回调通知
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse> wechatPaymentNotify(
        com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_WECHAT_PAYMENT_NOTIFY, getCallOptions()), request);
    }

    /**
     * <pre>
     *获取订单信息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.GetOrderInfeResponse> getOrderInfo(
        com.ywt.gapi.ordercenter.GetOrderInfoRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_ORDER_INFO, getCallOptions()), request);
    }

    /**
     * <pre>
     *更新订单信息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.UpdateOrderInfoResponse> updateOrderInfo(
        com.ywt.gapi.ordercenter.UpdateOrderInfoRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_UPDATE_ORDER_INFO, getCallOptions()), request);
    }

    /**
     * <pre>
     *退款
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.RefundResponse> refund(
        com.ywt.gapi.ordercenter.RefundRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_REFUND, getCallOptions()), request);
    }

    /**
     * <pre>
     *支付中心微信退款成功通知
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.WechatRefundNotifyResponse> wechatRefundNotify(
        com.ywt.gapi.ordercenter.WechatRefundNotifyRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_WECHAT_REFUND_NOTIFY, getCallOptions()), request);
    }

    /**
     * <pre>
     *获取订单中心账单
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.GetOrderBillResponse> getOrderBill(
        com.ywt.gapi.ordercenter.GetOrderBillRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_ORDER_BILL, getCallOptions()), request);
    }

    /**
     * <pre>
     *POS机申请预支付信息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.PrePayByPOSResponse> prePayByPOS(
        com.ywt.gapi.ordercenter.PrePayByPOSRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_PRE_PAY_BY_POS, getCallOptions()), request);
    }

    /**
     * <pre>
     *POS机完成支付信息更新
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.FinishPayByPOSResponse> finishPayByPOS(
        com.ywt.gapi.ordercenter.FinishPayByPOSRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_FINISH_PAY_BY_POS, getCallOptions()), request);
    }

    /**
     * <pre>
     *ICBC支付方式支付订单
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.ICBCPaymentResponse> icbcPayment(
        com.ywt.gapi.ordercenter.ICBCPaymentRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_ICBC_PAYMENT, getCallOptions()), request);
    }

    /**
     * <pre>
     *支付中心ICBC支付成功后回调通知
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse> icbcPaymentNotify(
        com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_ICBC_PAYMENT_NOTIFY, getCallOptions()), request);
    }

    /**
     * <pre>
     *支付中心工行退款成功通知
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse> icbcRefundNotify(
        com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_ICBC_REFUND_NOTIFY, getCallOptions()), request);
    }

    /**
     * <pre>
     *清除支付锁
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.CleanPayLockResponse> cleanPayLock(
        com.ywt.gapi.ordercenter.CleanPayLockRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_CLEAN_PAY_LOCK, getCallOptions()), request);
    }

    /**
     * <pre>
     *判断是否在支付中
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.ordercenter.CheckIsPayingResponse> checkIsPaying(
        com.ywt.gapi.ordercenter.CheckIsPayingRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_CHECK_IS_PAYING, getCallOptions()), request);
    }
  }

  private static final int METHODID_CREATE_ORDER = 0;
  private static final int METHODID_PAY_BY_ADMIN = 1;
  private static final int METHODID_WECHAT_PAYMENT = 2;
  private static final int METHODID_WECHAT_PAYMENT_NOTIFY = 3;
  private static final int METHODID_GET_ORDER_INFO = 4;
  private static final int METHODID_UPDATE_ORDER_INFO = 5;
  private static final int METHODID_REFUND = 6;
  private static final int METHODID_WECHAT_REFUND_NOTIFY = 7;
  private static final int METHODID_GET_ORDER_BILL = 8;
  private static final int METHODID_PRE_PAY_BY_POS = 9;
  private static final int METHODID_FINISH_PAY_BY_POS = 10;
  private static final int METHODID_ICBC_PAYMENT = 11;
  private static final int METHODID_ICBC_PAYMENT_NOTIFY = 12;
  private static final int METHODID_ICBC_REFUND_NOTIFY = 13;
  private static final int METHODID_CLEAN_PAY_LOCK = 14;
  private static final int METHODID_CHECK_IS_PAYING = 15;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final OrderCenterServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(OrderCenterServiceImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_CREATE_ORDER:
          serviceImpl.createOrder((com.ywt.gapi.ordercenter.CreateOrderRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CreateOrderResponse>) responseObserver);
          break;
        case METHODID_PAY_BY_ADMIN:
          serviceImpl.payByAdmin((com.ywt.gapi.ordercenter.PayByAdminRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.PayByAdminResponse>) responseObserver);
          break;
        case METHODID_WECHAT_PAYMENT:
          serviceImpl.wechatPayment((com.ywt.gapi.ordercenter.WechatPaymentRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatPaymentResponse>) responseObserver);
          break;
        case METHODID_WECHAT_PAYMENT_NOTIFY:
          serviceImpl.wechatPaymentNotify((com.ywt.gapi.ordercenter.WechatPaymentNotifyRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatPaymentNotifyResponse>) responseObserver);
          break;
        case METHODID_GET_ORDER_INFO:
          serviceImpl.getOrderInfo((com.ywt.gapi.ordercenter.GetOrderInfoRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.GetOrderInfeResponse>) responseObserver);
          break;
        case METHODID_UPDATE_ORDER_INFO:
          serviceImpl.updateOrderInfo((com.ywt.gapi.ordercenter.UpdateOrderInfoRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.UpdateOrderInfoResponse>) responseObserver);
          break;
        case METHODID_REFUND:
          serviceImpl.refund((com.ywt.gapi.ordercenter.RefundRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.RefundResponse>) responseObserver);
          break;
        case METHODID_WECHAT_REFUND_NOTIFY:
          serviceImpl.wechatRefundNotify((com.ywt.gapi.ordercenter.WechatRefundNotifyRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.WechatRefundNotifyResponse>) responseObserver);
          break;
        case METHODID_GET_ORDER_BILL:
          serviceImpl.getOrderBill((com.ywt.gapi.ordercenter.GetOrderBillRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.GetOrderBillResponse>) responseObserver);
          break;
        case METHODID_PRE_PAY_BY_POS:
          serviceImpl.prePayByPOS((com.ywt.gapi.ordercenter.PrePayByPOSRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.PrePayByPOSResponse>) responseObserver);
          break;
        case METHODID_FINISH_PAY_BY_POS:
          serviceImpl.finishPayByPOS((com.ywt.gapi.ordercenter.FinishPayByPOSRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.FinishPayByPOSResponse>) responseObserver);
          break;
        case METHODID_ICBC_PAYMENT:
          serviceImpl.icbcPayment((com.ywt.gapi.ordercenter.ICBCPaymentRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCPaymentResponse>) responseObserver);
          break;
        case METHODID_ICBC_PAYMENT_NOTIFY:
          serviceImpl.icbcPaymentNotify((com.ywt.gapi.ordercenter.ICBCPaymentNotifyRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCPaymentNotifyResponse>) responseObserver);
          break;
        case METHODID_ICBC_REFUND_NOTIFY:
          serviceImpl.icbcRefundNotify((com.ywt.gapi.ordercenter.ICBCRefundNotifyRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.ICBCRefundNotifyResponse>) responseObserver);
          break;
        case METHODID_CLEAN_PAY_LOCK:
          serviceImpl.cleanPayLock((com.ywt.gapi.ordercenter.CleanPayLockRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CleanPayLockResponse>) responseObserver);
          break;
        case METHODID_CHECK_IS_PAYING:
          serviceImpl.checkIsPaying((com.ywt.gapi.ordercenter.CheckIsPayingRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.ordercenter.CheckIsPayingResponse>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class OrderCenterServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    OrderCenterServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return com.ywt.gapi.ordercenter.Ordercenter.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("OrderCenterService");
    }
  }

  private static final class OrderCenterServiceFileDescriptorSupplier
      extends OrderCenterServiceBaseDescriptorSupplier {
    OrderCenterServiceFileDescriptorSupplier() {}
  }

  private static final class OrderCenterServiceMethodDescriptorSupplier
      extends OrderCenterServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    OrderCenterServiceMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (OrderCenterServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new OrderCenterServiceFileDescriptorSupplier())
              .addMethod(METHOD_CREATE_ORDER)
              .addMethod(METHOD_PAY_BY_ADMIN)
              .addMethod(METHOD_WECHAT_PAYMENT)
              .addMethod(METHOD_WECHAT_PAYMENT_NOTIFY)
              .addMethod(METHOD_GET_ORDER_INFO)
              .addMethod(METHOD_UPDATE_ORDER_INFO)
              .addMethod(METHOD_REFUND)
              .addMethod(METHOD_WECHAT_REFUND_NOTIFY)
              .addMethod(METHOD_GET_ORDER_BILL)
              .addMethod(METHOD_PRE_PAY_BY_POS)
              .addMethod(METHOD_FINISH_PAY_BY_POS)
              .addMethod(METHOD_ICBC_PAYMENT)
              .addMethod(METHOD_ICBC_PAYMENT_NOTIFY)
              .addMethod(METHOD_ICBC_REFUND_NOTIFY)
              .addMethod(METHOD_CLEAN_PAY_LOCK)
              .addMethod(METHOD_CHECK_IS_PAYING)
              .build();
        }
      }
    }
    return result;
  }
}
