package com.ywt.gapi.wx_ins_pay;

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>
 * 微信医保支付接口，实现在中控-wxInsPay-index.js
 * </pre>
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.7.0)",
    comments = "Source: wx_ins_pay.proto")
public final class WxInsPayServiceGrpc {

  private WxInsPayServiceGrpc() {}

  public static final String SERVICE_NAME = "com.ywt.gapi.wx_ins_pay.WxInsPayService";

  // 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.wx_ins_pay.CreatePayInsOrderRequest,
      com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse> METHOD_CREATE_PAY_INS_ORDER =
      io.grpc.MethodDescriptor.<com.ywt.gapi.wx_ins_pay.CreatePayInsOrderRequest, com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.wx_ins_pay.WxInsPayService", "createPayInsOrder"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.CreatePayInsOrderRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse.getDefaultInstance()))
          .setSchemaDescriptor(new WxInsPayServiceMethodDescriptorSupplier("createPayInsOrder"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest,
      com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse> METHOD_QUERY_PAY_INS_ORDER =
      io.grpc.MethodDescriptor.<com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest, com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.wx_ins_pay.WxInsPayService", "queryPayInsOrder"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse.getDefaultInstance()))
          .setSchemaDescriptor(new WxInsPayServiceMethodDescriptorSupplier("queryPayInsOrder"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest,
      com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse> METHOD_WX_PAY_CALLBACK =
      io.grpc.MethodDescriptor.<com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest, com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.wx_ins_pay.WxInsPayService", "wxPayCallback"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse.getDefaultInstance()))
          .setSchemaDescriptor(new WxInsPayServiceMethodDescriptorSupplier("wxPayCallback"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest,
      com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse> METHOD_VERIFY_MED_INFO =
      io.grpc.MethodDescriptor.<com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest, com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.wx_ins_pay.WxInsPayService", "verifyMedInfo"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse.getDefaultInstance()))
          .setSchemaDescriptor(new WxInsPayServiceMethodDescriptorSupplier("verifyMedInfo"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest,
      com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse> METHOD_MARK_OP_ORDER_DELETED =
      io.grpc.MethodDescriptor.<com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest, com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.wx_ins_pay.WxInsPayService", "markOpOrderDeleted"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse.getDefaultInstance()))
          .setSchemaDescriptor(new WxInsPayServiceMethodDescriptorSupplier("markOpOrderDeleted"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest,
      com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse> METHOD_WECHAT_AUTO_REFUND_CALLBACK =
      io.grpc.MethodDescriptor.<com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest, com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.wx_ins_pay.WxInsPayService", "wechatAutoRefundCallback"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse.getDefaultInstance()))
          .setSchemaDescriptor(new WxInsPayServiceMethodDescriptorSupplier("wechatAutoRefundCallback"))
          .build();

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

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

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

  /**
   * <pre>
   * 微信医保支付接口，实现在中控-wxInsPay-index.js
   * </pre>
   */
  public static abstract class WxInsPayServiceImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     * 挂号/诊间支付统一下单 API 接口
     * </pre>
     */
    public void createPayInsOrder(com.ywt.gapi.wx_ins_pay.CreatePayInsOrderRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_CREATE_PAY_INS_ORDER, responseObserver);
    }

    /**
     * <pre>
     * 查询订单
     * </pre>
     */
    public void queryPayInsOrder(com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_QUERY_PAY_INS_ORDER, responseObserver);
    }

    /**
     * <pre>
     * 支付回调
     * </pre>
     */
    public void wxPayCallback(com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_WX_PAY_CALLBACK, responseObserver);
    }

    /**
     * <pre>
     * 退款
     * rpc refund (RefundRequest) returns (RefundResponse);
     * 查询医保卡信息/查询是否绑定医保卡
     * </pre>
     */
    public void verifyMedInfo(com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_VERIFY_MED_INFO, responseObserver);
    }

    /**
     * <pre>
     * 把订单标记为删除，主要用于腾讯下单失败时将已生成的订单删除，让用户可以重新下单。为了方便线上测试，把该方法实现放在医保服务中
     * </pre>
     */
    public void markOpOrderDeleted(com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_MARK_OP_ORDER_DELETED, responseObserver);
    }

    /**
     * <pre>
     * 自费门诊订单，微信支付原路退回成功回调
     * </pre>
     */
    public void wechatAutoRefundCallback(com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_WECHAT_AUTO_REFUND_CALLBACK, responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            METHOD_CREATE_PAY_INS_ORDER,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.wx_ins_pay.CreatePayInsOrderRequest,
                com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse>(
                  this, METHODID_CREATE_PAY_INS_ORDER)))
          .addMethod(
            METHOD_QUERY_PAY_INS_ORDER,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest,
                com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse>(
                  this, METHODID_QUERY_PAY_INS_ORDER)))
          .addMethod(
            METHOD_WX_PAY_CALLBACK,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest,
                com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse>(
                  this, METHODID_WX_PAY_CALLBACK)))
          .addMethod(
            METHOD_VERIFY_MED_INFO,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest,
                com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse>(
                  this, METHODID_VERIFY_MED_INFO)))
          .addMethod(
            METHOD_MARK_OP_ORDER_DELETED,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest,
                com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse>(
                  this, METHODID_MARK_OP_ORDER_DELETED)))
          .addMethod(
            METHOD_WECHAT_AUTO_REFUND_CALLBACK,
            asyncUnaryCall(
              new MethodHandlers<
                com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest,
                com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse>(
                  this, METHODID_WECHAT_AUTO_REFUND_CALLBACK)))
          .build();
    }
  }

  /**
   * <pre>
   * 微信医保支付接口，实现在中控-wxInsPay-index.js
   * </pre>
   */
  public static final class WxInsPayServiceStub extends io.grpc.stub.AbstractStub<WxInsPayServiceStub> {
    private WxInsPayServiceStub(io.grpc.Channel channel) {
      super(channel);
    }

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

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

    /**
     * <pre>
     * 挂号/诊间支付统一下单 API 接口
     * </pre>
     */
    public void createPayInsOrder(com.ywt.gapi.wx_ins_pay.CreatePayInsOrderRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_CREATE_PAY_INS_ORDER, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 查询订单
     * </pre>
     */
    public void queryPayInsOrder(com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_QUERY_PAY_INS_ORDER, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 支付回调
     * </pre>
     */
    public void wxPayCallback(com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_WX_PAY_CALLBACK, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 退款
     * rpc refund (RefundRequest) returns (RefundResponse);
     * 查询医保卡信息/查询是否绑定医保卡
     * </pre>
     */
    public void verifyMedInfo(com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_VERIFY_MED_INFO, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 把订单标记为删除，主要用于腾讯下单失败时将已生成的订单删除，让用户可以重新下单。为了方便线上测试，把该方法实现放在医保服务中
     * </pre>
     */
    public void markOpOrderDeleted(com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_MARK_OP_ORDER_DELETED, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 自费门诊订单，微信支付原路退回成功回调
     * </pre>
     */
    public void wechatAutoRefundCallback(com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest request,
        io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_WECHAT_AUTO_REFUND_CALLBACK, getCallOptions()), request, responseObserver);
    }
  }

  /**
   * <pre>
   * 微信医保支付接口，实现在中控-wxInsPay-index.js
   * </pre>
   */
  public static final class WxInsPayServiceBlockingStub extends io.grpc.stub.AbstractStub<WxInsPayServiceBlockingStub> {
    private WxInsPayServiceBlockingStub(io.grpc.Channel channel) {
      super(channel);
    }

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

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

    /**
     * <pre>
     * 挂号/诊间支付统一下单 API 接口
     * </pre>
     */
    public com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse createPayInsOrder(com.ywt.gapi.wx_ins_pay.CreatePayInsOrderRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_CREATE_PAY_INS_ORDER, getCallOptions(), request);
    }

    /**
     * <pre>
     * 查询订单
     * </pre>
     */
    public com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse queryPayInsOrder(com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_QUERY_PAY_INS_ORDER, getCallOptions(), request);
    }

    /**
     * <pre>
     * 支付回调
     * </pre>
     */
    public com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse wxPayCallback(com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_WX_PAY_CALLBACK, getCallOptions(), request);
    }

    /**
     * <pre>
     * 退款
     * rpc refund (RefundRequest) returns (RefundResponse);
     * 查询医保卡信息/查询是否绑定医保卡
     * </pre>
     */
    public com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse verifyMedInfo(com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_VERIFY_MED_INFO, getCallOptions(), request);
    }

    /**
     * <pre>
     * 把订单标记为删除，主要用于腾讯下单失败时将已生成的订单删除，让用户可以重新下单。为了方便线上测试，把该方法实现放在医保服务中
     * </pre>
     */
    public com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse markOpOrderDeleted(com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_MARK_OP_ORDER_DELETED, getCallOptions(), request);
    }

    /**
     * <pre>
     * 自费门诊订单，微信支付原路退回成功回调
     * </pre>
     */
    public com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse wechatAutoRefundCallback(com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_WECHAT_AUTO_REFUND_CALLBACK, getCallOptions(), request);
    }
  }

  /**
   * <pre>
   * 微信医保支付接口，实现在中控-wxInsPay-index.js
   * </pre>
   */
  public static final class WxInsPayServiceFutureStub extends io.grpc.stub.AbstractStub<WxInsPayServiceFutureStub> {
    private WxInsPayServiceFutureStub(io.grpc.Channel channel) {
      super(channel);
    }

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

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

    /**
     * <pre>
     * 挂号/诊间支付统一下单 API 接口
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse> createPayInsOrder(
        com.ywt.gapi.wx_ins_pay.CreatePayInsOrderRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_CREATE_PAY_INS_ORDER, getCallOptions()), request);
    }

    /**
     * <pre>
     * 查询订单
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse> queryPayInsOrder(
        com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_QUERY_PAY_INS_ORDER, getCallOptions()), request);
    }

    /**
     * <pre>
     * 支付回调
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse> wxPayCallback(
        com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_WX_PAY_CALLBACK, getCallOptions()), request);
    }

    /**
     * <pre>
     * 退款
     * rpc refund (RefundRequest) returns (RefundResponse);
     * 查询医保卡信息/查询是否绑定医保卡
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse> verifyMedInfo(
        com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_VERIFY_MED_INFO, getCallOptions()), request);
    }

    /**
     * <pre>
     * 把订单标记为删除，主要用于腾讯下单失败时将已生成的订单删除，让用户可以重新下单。为了方便线上测试，把该方法实现放在医保服务中
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse> markOpOrderDeleted(
        com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_MARK_OP_ORDER_DELETED, getCallOptions()), request);
    }

    /**
     * <pre>
     * 自费门诊订单，微信支付原路退回成功回调
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse> wechatAutoRefundCallback(
        com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_WECHAT_AUTO_REFUND_CALLBACK, getCallOptions()), request);
    }
  }

  private static final int METHODID_CREATE_PAY_INS_ORDER = 0;
  private static final int METHODID_QUERY_PAY_INS_ORDER = 1;
  private static final int METHODID_WX_PAY_CALLBACK = 2;
  private static final int METHODID_VERIFY_MED_INFO = 3;
  private static final int METHODID_MARK_OP_ORDER_DELETED = 4;
  private static final int METHODID_WECHAT_AUTO_REFUND_CALLBACK = 5;

  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 WxInsPayServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(WxInsPayServiceImplBase 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_PAY_INS_ORDER:
          serviceImpl.createPayInsOrder((com.ywt.gapi.wx_ins_pay.CreatePayInsOrderRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.CreatePayInsOrderResponse>) responseObserver);
          break;
        case METHODID_QUERY_PAY_INS_ORDER:
          serviceImpl.queryPayInsOrder((com.ywt.gapi.wx_ins_pay.QueryPayInsOrderRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.QueryPayInsOrderResponse>) responseObserver);
          break;
        case METHODID_WX_PAY_CALLBACK:
          serviceImpl.wxPayCallback((com.ywt.gapi.wx_ins_pay.WxPayCallbackRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.WxPayCallbackResponse>) responseObserver);
          break;
        case METHODID_VERIFY_MED_INFO:
          serviceImpl.verifyMedInfo((com.ywt.gapi.wx_ins_pay.VerifyMedInfoRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.VerifyMedInfoResponse>) responseObserver);
          break;
        case METHODID_MARK_OP_ORDER_DELETED:
          serviceImpl.markOpOrderDeleted((com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.MarkOpOrderDeletedResponse>) responseObserver);
          break;
        case METHODID_WECHAT_AUTO_REFUND_CALLBACK:
          serviceImpl.wechatAutoRefundCallback((com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackRequest) request,
              (io.grpc.stub.StreamObserver<com.ywt.gapi.wx_ins_pay.WechatAutoRefundCallbackResponse>) 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 WxInsPayServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    WxInsPayServiceBaseDescriptorSupplier() {}

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

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

  private static final class WxInsPayServiceFileDescriptorSupplier
      extends WxInsPayServiceBaseDescriptorSupplier {
    WxInsPayServiceFileDescriptorSupplier() {}
  }

  private static final class WxInsPayServiceMethodDescriptorSupplier
      extends WxInsPayServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    WxInsPayServiceMethodDescriptorSupplier(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 (WxInsPayServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new WxInsPayServiceFileDescriptorSupplier())
              .addMethod(METHOD_CREATE_PAY_INS_ORDER)
              .addMethod(METHOD_QUERY_PAY_INS_ORDER)
              .addMethod(METHOD_WX_PAY_CALLBACK)
              .addMethod(METHOD_VERIFY_MED_INFO)
              .addMethod(METHOD_MARK_OP_ORDER_DELETED)
              .addMethod(METHOD_WECHAT_AUTO_REFUND_CALLBACK)
              .build();
        }
      }
    }
    return result;
  }
}
