package com.ywt.gapi.taihe.outpaitent;

import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;

/**
 * <pre>
 *太和门诊服务类    // 对应 taihe-service 项目的 TaiheOutpatientServiceImpl 类
 * </pre>
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.7.0)",
    comments = "Source: taihe_outpatient.proto")
public final class TaiheOutpatientServiceGrpc {

  private TaiheOutpatientServiceGrpc() {}

  public static final String SERVICE_NAME = "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService";

  // 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<CreateOutpatientRequest,
      CreateOutpatientResponse> METHOD_CREATE_OUTPATIENT =
      io.grpc.MethodDescriptor.<CreateOutpatientRequest, CreateOutpatientResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "createOutpatient"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              CreateOutpatientRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              CreateOutpatientResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("createOutpatient"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<PayCallbackRequest,
      PayCallbackResponse> METHOD_PAY_CALLBACK =
      io.grpc.MethodDescriptor.<PayCallbackRequest, PayCallbackResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "payCallback"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              PayCallbackRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              PayCallbackResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("payCallback"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetOutpatientQrcodeRequest,
      GetOutpatientQrcodeResponse> METHOD_GET_OUTPATIENT_QRCODE =
      io.grpc.MethodDescriptor.<GetOutpatientQrcodeRequest, GetOutpatientQrcodeResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getOutpatientQrcode"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientQrcodeRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientQrcodeResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getOutpatientQrcode"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetOutpatientDetailRequest,
      GetOutpatientDetailResponse> METHOD_GET_OUTPATIENT_DETAIL =
      io.grpc.MethodDescriptor.<GetOutpatientDetailRequest, GetOutpatientDetailResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getOutpatientDetail"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientDetailRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientDetailResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getOutpatientDetail"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<UpdateOutpatientRequest,
      UpdateOutpatientResponse> METHOD_UPDATE_OUTPATIENT =
      io.grpc.MethodDescriptor.<UpdateOutpatientRequest, UpdateOutpatientResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "updateOutpatient"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              UpdateOutpatientRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              UpdateOutpatientResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("updateOutpatient"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<RefundOutpatientCallbackRequest,
      RefundOutpatientCallbackResponse> METHOD_REFUND_OUTPATIENT_CALLBACK =
      io.grpc.MethodDescriptor.<RefundOutpatientCallbackRequest, RefundOutpatientCallbackResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "refundOutpatientCallback"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              RefundOutpatientCallbackRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              RefundOutpatientCallbackResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("refundOutpatientCallback"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetOutpatientListRequest,
      GetOutpatientListResponse> METHOD_GET_OUTPATIENT_LIST =
      io.grpc.MethodDescriptor.<GetOutpatientListRequest, GetOutpatientListResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getOutpatientList"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientListRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientListResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getOutpatientList"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetMedicalCardInfoByPatientIdRequest,
      GetMedicalCardInfoByPatientIdResponse> METHOD_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID =
      io.grpc.MethodDescriptor.<GetMedicalCardInfoByPatientIdRequest, GetMedicalCardInfoByPatientIdResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getMedicalCardInfoByPatientId"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetMedicalCardInfoByPatientIdRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetMedicalCardInfoByPatientIdResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getMedicalCardInfoByPatientId"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetOutpatientOrderByHisOrderNoRequest,
      GetOutpatientOrderByHisOrderNoResponse> METHOD_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO =
      io.grpc.MethodDescriptor.<GetOutpatientOrderByHisOrderNoRequest, GetOutpatientOrderByHisOrderNoResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getOutpatientOrderByHisOrderNo"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientOrderByHisOrderNoRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientOrderByHisOrderNoResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getOutpatientOrderByHisOrderNo"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<SaveOutpatientOrderDetailsRequest,
      BaseResult> METHOD_SAVE_OUTPATIENT_ORDER_DETAILS =
      io.grpc.MethodDescriptor.<SaveOutpatientOrderDetailsRequest, BaseResult>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "saveOutpatientOrderDetails"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              SaveOutpatientOrderDetailsRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              BaseResult.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("saveOutpatientOrderDetails"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetOutpatientOrderDetailRequest,
      GetOutpatientOrderDetailResponse> METHOD_GET_OUTPATIENT_ORDER_DETAIL =
      io.grpc.MethodDescriptor.<GetOutpatientOrderDetailRequest, GetOutpatientOrderDetailResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getOutpatientOrderDetail"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientOrderDetailRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutpatientOrderDetailResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getOutpatientOrderDetail"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetMedicalCardInfoByIdRequest,
      GetMedicalCardInfoByPatientIdResponse> METHOD_GET_MEDICAL_CARD_INFO_BY_ID =
      io.grpc.MethodDescriptor.<GetMedicalCardInfoByIdRequest, GetMedicalCardInfoByPatientIdResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getMedicalCardInfoById"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetMedicalCardInfoByIdRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetMedicalCardInfoByPatientIdResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getMedicalCardInfoById"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<UpdateOutpatientOrderRequest,
      UpdateOutpatientOrderResponse> METHOD_UPDATE_OUTPATIENT_ORDER =
      io.grpc.MethodDescriptor.<UpdateOutpatientOrderRequest, UpdateOutpatientOrderResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "updateOutpatientOrder"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              UpdateOutpatientOrderRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              UpdateOutpatientOrderResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("updateOutpatientOrder"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetLatestOutpatientOrderRequest,
      GetLatestOutpatientOrderResponse> METHOD_GET_LATEST_OUTPATIENT_ORDER =
      io.grpc.MethodDescriptor.<GetLatestOutpatientOrderRequest, GetLatestOutpatientOrderResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getLatestOutpatientOrder"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetLatestOutpatientOrderRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetLatestOutpatientOrderResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getLatestOutpatientOrder"))
          .build();
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static final io.grpc.MethodDescriptor<GetOutPatientConfigRequest,
      GetOutPatientConfigResponse> METHOD_GET_OUTPATIENT_CONFIGS =
      io.grpc.MethodDescriptor.<GetOutPatientConfigRequest, GetOutPatientConfigResponse>newBuilder()
          .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
          .setFullMethodName(generateFullMethodName(
              "com.ywt.gapi.taihe.outpaitent.TaiheOutpatientService", "getOutpatientConfigs"))
          .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutPatientConfigRequest.getDefaultInstance()))
          .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
              GetOutPatientConfigResponse.getDefaultInstance()))
          .setSchemaDescriptor(new TaiheOutpatientServiceMethodDescriptorSupplier("getOutpatientConfigs"))
          .build();

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

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

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

  /**
   * <pre>
   *太和门诊服务类    // 对应 taihe-service 项目的 TaiheOutpatientServiceImpl 类
   * </pre>
   */
  public static abstract class TaiheOutpatientServiceImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     *生成门诊缴费单
     * </pre>
     */
    public void createOutpatient(CreateOutpatientRequest request,
                                 io.grpc.stub.StreamObserver<CreateOutpatientResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_CREATE_OUTPATIENT, responseObserver);
    }

    /**
     * <pre>
     *订单支付成功通知
     * </pre>
     */
    public void payCallback(PayCallbackRequest request,
                            io.grpc.stub.StreamObserver<PayCallbackResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_PAY_CALLBACK, responseObserver);
    }

    /**
     * <pre>
     *获取门诊缴费单二维码
     * </pre>
     */
    public void getOutpatientQrcode(GetOutpatientQrcodeRequest request,
                                    io.grpc.stub.StreamObserver<GetOutpatientQrcodeResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_OUTPATIENT_QRCODE, responseObserver);
    }

    /**
     * <pre>
     *获取门诊缴费单详情
     * </pre>
     */
    public void getOutpatientDetail(GetOutpatientDetailRequest request,
                                    io.grpc.stub.StreamObserver<GetOutpatientDetailResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_OUTPATIENT_DETAIL, responseObserver);
    }

    /**
     * <pre>
     *更新门诊单信息
     * </pre>
     */
    public void updateOutpatient(UpdateOutpatientRequest request,
                                 io.grpc.stub.StreamObserver<UpdateOutpatientResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_UPDATE_OUTPATIENT, responseObserver);
    }

    /**
     * <pre>
     *门诊缴费订单退款回调
     * </pre>
     */
    public void refundOutpatientCallback(RefundOutpatientCallbackRequest request,
                                         io.grpc.stub.StreamObserver<RefundOutpatientCallbackResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_REFUND_OUTPATIENT_CALLBACK, responseObserver);
    }

    /**
     * <pre>
     *获取门诊缴费单列表
     * </pre>
     */
    public void getOutpatientList(GetOutpatientListRequest request,
                                  io.grpc.stub.StreamObserver<GetOutpatientListResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_OUTPATIENT_LIST, responseObserver);
    }

    /**
     * <pre>
     * 根据 his_patient_id 获取诊疗卡信息
     * </pre>
     */
    public void getMedicalCardInfoByPatientId(GetMedicalCardInfoByPatientIdRequest request,
                                              io.grpc.stub.StreamObserver<GetMedicalCardInfoByPatientIdResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID, responseObserver);
    }

    /**
     * <pre>
     * 根据 his_order_no 获取门诊订单信息
     * </pre>
     */
    public void getOutpatientOrderByHisOrderNo(GetOutpatientOrderByHisOrderNoRequest request,
                                               io.grpc.stub.StreamObserver<GetOutpatientOrderByHisOrderNoResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO, responseObserver);
    }

    /**
     * <pre>
     * 保存门诊缴费订单明细
     * </pre>
     */
    public void saveOutpatientOrderDetails(SaveOutpatientOrderDetailsRequest request,
                                           io.grpc.stub.StreamObserver<BaseResult> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_SAVE_OUTPATIENT_ORDER_DETAILS, responseObserver);
    }

    /**
     * <pre>
     * 获取门诊缴费订单明细
     * </pre>
     */
    public void getOutpatientOrderDetail(GetOutpatientOrderDetailRequest request,
                                         io.grpc.stub.StreamObserver<GetOutpatientOrderDetailResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_OUTPATIENT_ORDER_DETAIL, responseObserver);
    }

    /**
     * <pre>
     * 根据 medical_id 获取诊疗卡信息
     * </pre>
     */
    public void getMedicalCardInfoById(GetMedicalCardInfoByIdRequest request,
                                       io.grpc.stub.StreamObserver<GetMedicalCardInfoByPatientIdResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_MEDICAL_CARD_INFO_BY_ID, responseObserver);
    }

    /**
     * <pre>
     * 更新 outpatient order
     * </pre>
     */
    public void updateOutpatientOrder(UpdateOutpatientOrderRequest request,
                                      io.grpc.stub.StreamObserver<UpdateOutpatientOrderResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_UPDATE_OUTPATIENT_ORDER, responseObserver);
    }

    /**
     * <pre>
     * 获取最近一次门诊缴费
     * </pre>
     */
    public void getLatestOutpatientOrder(GetLatestOutpatientOrderRequest request,
                                         io.grpc.stub.StreamObserver<GetLatestOutpatientOrderResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_LATEST_OUTPATIENT_ORDER, responseObserver);
    }

    /**
     */
    public void getOutpatientConfigs(GetOutPatientConfigRequest request,
                                     io.grpc.stub.StreamObserver<GetOutPatientConfigResponse> responseObserver) {
      asyncUnimplementedUnaryCall(METHOD_GET_OUTPATIENT_CONFIGS, responseObserver);
    }

    @Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            METHOD_CREATE_OUTPATIENT,
            asyncUnaryCall(
              new MethodHandlers<
                CreateOutpatientRequest,
                CreateOutpatientResponse>(
                  this, METHODID_CREATE_OUTPATIENT)))
          .addMethod(
            METHOD_PAY_CALLBACK,
            asyncUnaryCall(
              new MethodHandlers<
                PayCallbackRequest,
                PayCallbackResponse>(
                  this, METHODID_PAY_CALLBACK)))
          .addMethod(
            METHOD_GET_OUTPATIENT_QRCODE,
            asyncUnaryCall(
              new MethodHandlers<
                GetOutpatientQrcodeRequest,
                GetOutpatientQrcodeResponse>(
                  this, METHODID_GET_OUTPATIENT_QRCODE)))
          .addMethod(
            METHOD_GET_OUTPATIENT_DETAIL,
            asyncUnaryCall(
              new MethodHandlers<
                GetOutpatientDetailRequest,
                GetOutpatientDetailResponse>(
                  this, METHODID_GET_OUTPATIENT_DETAIL)))
          .addMethod(
            METHOD_UPDATE_OUTPATIENT,
            asyncUnaryCall(
              new MethodHandlers<
                UpdateOutpatientRequest,
                UpdateOutpatientResponse>(
                  this, METHODID_UPDATE_OUTPATIENT)))
          .addMethod(
            METHOD_REFUND_OUTPATIENT_CALLBACK,
            asyncUnaryCall(
              new MethodHandlers<
                RefundOutpatientCallbackRequest,
                RefundOutpatientCallbackResponse>(
                  this, METHODID_REFUND_OUTPATIENT_CALLBACK)))
          .addMethod(
            METHOD_GET_OUTPATIENT_LIST,
            asyncUnaryCall(
              new MethodHandlers<
                GetOutpatientListRequest,
                GetOutpatientListResponse>(
                  this, METHODID_GET_OUTPATIENT_LIST)))
          .addMethod(
            METHOD_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID,
            asyncUnaryCall(
              new MethodHandlers<
                GetMedicalCardInfoByPatientIdRequest,
                GetMedicalCardInfoByPatientIdResponse>(
                  this, METHODID_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID)))
          .addMethod(
            METHOD_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO,
            asyncUnaryCall(
              new MethodHandlers<
                GetOutpatientOrderByHisOrderNoRequest,
                GetOutpatientOrderByHisOrderNoResponse>(
                  this, METHODID_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO)))
          .addMethod(
            METHOD_SAVE_OUTPATIENT_ORDER_DETAILS,
            asyncUnaryCall(
              new MethodHandlers<
                SaveOutpatientOrderDetailsRequest,
                BaseResult>(
                  this, METHODID_SAVE_OUTPATIENT_ORDER_DETAILS)))
          .addMethod(
            METHOD_GET_OUTPATIENT_ORDER_DETAIL,
            asyncUnaryCall(
              new MethodHandlers<
                GetOutpatientOrderDetailRequest,
                GetOutpatientOrderDetailResponse>(
                  this, METHODID_GET_OUTPATIENT_ORDER_DETAIL)))
          .addMethod(
            METHOD_GET_MEDICAL_CARD_INFO_BY_ID,
            asyncUnaryCall(
              new MethodHandlers<
                GetMedicalCardInfoByIdRequest,
                GetMedicalCardInfoByPatientIdResponse>(
                  this, METHODID_GET_MEDICAL_CARD_INFO_BY_ID)))
          .addMethod(
            METHOD_UPDATE_OUTPATIENT_ORDER,
            asyncUnaryCall(
              new MethodHandlers<
                UpdateOutpatientOrderRequest,
                UpdateOutpatientOrderResponse>(
                  this, METHODID_UPDATE_OUTPATIENT_ORDER)))
          .addMethod(
            METHOD_GET_LATEST_OUTPATIENT_ORDER,
            asyncUnaryCall(
              new MethodHandlers<
                GetLatestOutpatientOrderRequest,
                GetLatestOutpatientOrderResponse>(
                  this, METHODID_GET_LATEST_OUTPATIENT_ORDER)))
          .addMethod(
            METHOD_GET_OUTPATIENT_CONFIGS,
            asyncUnaryCall(
              new MethodHandlers<
                GetOutPatientConfigRequest,
                GetOutPatientConfigResponse>(
                  this, METHODID_GET_OUTPATIENT_CONFIGS)))
          .build();
    }
  }

  /**
   * <pre>
   *太和门诊服务类    // 对应 taihe-service 项目的 TaiheOutpatientServiceImpl 类
   * </pre>
   */
  public static final class TaiheOutpatientServiceStub extends io.grpc.stub.AbstractStub<TaiheOutpatientServiceStub> {
    private TaiheOutpatientServiceStub(io.grpc.Channel channel) {
      super(channel);
    }

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

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

    /**
     * <pre>
     *生成门诊缴费单
     * </pre>
     */
    public void createOutpatient(CreateOutpatientRequest request,
                                 io.grpc.stub.StreamObserver<CreateOutpatientResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_CREATE_OUTPATIENT, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *订单支付成功通知
     * </pre>
     */
    public void payCallback(PayCallbackRequest request,
                            io.grpc.stub.StreamObserver<PayCallbackResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_PAY_CALLBACK, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *获取门诊缴费单二维码
     * </pre>
     */
    public void getOutpatientQrcode(GetOutpatientQrcodeRequest request,
                                    io.grpc.stub.StreamObserver<GetOutpatientQrcodeResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_QRCODE, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *获取门诊缴费单详情
     * </pre>
     */
    public void getOutpatientDetail(GetOutpatientDetailRequest request,
                                    io.grpc.stub.StreamObserver<GetOutpatientDetailResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_DETAIL, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *更新门诊单信息
     * </pre>
     */
    public void updateOutpatient(UpdateOutpatientRequest request,
                                 io.grpc.stub.StreamObserver<UpdateOutpatientResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_UPDATE_OUTPATIENT, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *门诊缴费订单退款回调
     * </pre>
     */
    public void refundOutpatientCallback(RefundOutpatientCallbackRequest request,
                                         io.grpc.stub.StreamObserver<RefundOutpatientCallbackResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_REFUND_OUTPATIENT_CALLBACK, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *获取门诊缴费单列表
     * </pre>
     */
    public void getOutpatientList(GetOutpatientListRequest request,
                                  io.grpc.stub.StreamObserver<GetOutpatientListResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_LIST, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 根据 his_patient_id 获取诊疗卡信息
     * </pre>
     */
    public void getMedicalCardInfoByPatientId(GetMedicalCardInfoByPatientIdRequest request,
                                              io.grpc.stub.StreamObserver<GetMedicalCardInfoByPatientIdResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 根据 his_order_no 获取门诊订单信息
     * </pre>
     */
    public void getOutpatientOrderByHisOrderNo(GetOutpatientOrderByHisOrderNoRequest request,
                                               io.grpc.stub.StreamObserver<GetOutpatientOrderByHisOrderNoResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 保存门诊缴费订单明细
     * </pre>
     */
    public void saveOutpatientOrderDetails(SaveOutpatientOrderDetailsRequest request,
                                           io.grpc.stub.StreamObserver<BaseResult> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_SAVE_OUTPATIENT_ORDER_DETAILS, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 获取门诊缴费订单明细
     * </pre>
     */
    public void getOutpatientOrderDetail(GetOutpatientOrderDetailRequest request,
                                         io.grpc.stub.StreamObserver<GetOutpatientOrderDetailResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_ORDER_DETAIL, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 根据 medical_id 获取诊疗卡信息
     * </pre>
     */
    public void getMedicalCardInfoById(GetMedicalCardInfoByIdRequest request,
                                       io.grpc.stub.StreamObserver<GetMedicalCardInfoByPatientIdResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_MEDICAL_CARD_INFO_BY_ID, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 更新 outpatient order
     * </pre>
     */
    public void updateOutpatientOrder(UpdateOutpatientOrderRequest request,
                                      io.grpc.stub.StreamObserver<UpdateOutpatientOrderResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_UPDATE_OUTPATIENT_ORDER, getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 获取最近一次门诊缴费
     * </pre>
     */
    public void getLatestOutpatientOrder(GetLatestOutpatientOrderRequest request,
                                         io.grpc.stub.StreamObserver<GetLatestOutpatientOrderResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_LATEST_OUTPATIENT_ORDER, getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getOutpatientConfigs(GetOutPatientConfigRequest request,
                                     io.grpc.stub.StreamObserver<GetOutPatientConfigResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_CONFIGS, getCallOptions()), request, responseObserver);
    }
  }

  /**
   * <pre>
   *太和门诊服务类    // 对应 taihe-service 项目的 TaiheOutpatientServiceImpl 类
   * </pre>
   */
  public static final class TaiheOutpatientServiceBlockingStub extends io.grpc.stub.AbstractStub<TaiheOutpatientServiceBlockingStub> {
    private TaiheOutpatientServiceBlockingStub(io.grpc.Channel channel) {
      super(channel);
    }

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

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

    /**
     * <pre>
     *生成门诊缴费单
     * </pre>
     */
    public CreateOutpatientResponse createOutpatient(CreateOutpatientRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_CREATE_OUTPATIENT, getCallOptions(), request);
    }

    /**
     * <pre>
     *订单支付成功通知
     * </pre>
     */
    public PayCallbackResponse payCallback(PayCallbackRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_PAY_CALLBACK, getCallOptions(), request);
    }

    /**
     * <pre>
     *获取门诊缴费单二维码
     * </pre>
     */
    public GetOutpatientQrcodeResponse getOutpatientQrcode(GetOutpatientQrcodeRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_OUTPATIENT_QRCODE, getCallOptions(), request);
    }

    /**
     * <pre>
     *获取门诊缴费单详情
     * </pre>
     */
    public GetOutpatientDetailResponse getOutpatientDetail(GetOutpatientDetailRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_OUTPATIENT_DETAIL, getCallOptions(), request);
    }

    /**
     * <pre>
     *更新门诊单信息
     * </pre>
     */
    public UpdateOutpatientResponse updateOutpatient(UpdateOutpatientRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_UPDATE_OUTPATIENT, getCallOptions(), request);
    }

    /**
     * <pre>
     *门诊缴费订单退款回调
     * </pre>
     */
    public RefundOutpatientCallbackResponse refundOutpatientCallback(RefundOutpatientCallbackRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_REFUND_OUTPATIENT_CALLBACK, getCallOptions(), request);
    }

    /**
     * <pre>
     *获取门诊缴费单列表
     * </pre>
     */
    public GetOutpatientListResponse getOutpatientList(GetOutpatientListRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_OUTPATIENT_LIST, getCallOptions(), request);
    }

    /**
     * <pre>
     * 根据 his_patient_id 获取诊疗卡信息
     * </pre>
     */
    public GetMedicalCardInfoByPatientIdResponse getMedicalCardInfoByPatientId(GetMedicalCardInfoByPatientIdRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID, getCallOptions(), request);
    }

    /**
     * <pre>
     * 根据 his_order_no 获取门诊订单信息
     * </pre>
     */
    public GetOutpatientOrderByHisOrderNoResponse getOutpatientOrderByHisOrderNo(GetOutpatientOrderByHisOrderNoRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO, getCallOptions(), request);
    }

    /**
     * <pre>
     * 保存门诊缴费订单明细
     * </pre>
     */
    public BaseResult saveOutpatientOrderDetails(SaveOutpatientOrderDetailsRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_SAVE_OUTPATIENT_ORDER_DETAILS, getCallOptions(), request);
    }

    /**
     * <pre>
     * 获取门诊缴费订单明细
     * </pre>
     */
    public GetOutpatientOrderDetailResponse getOutpatientOrderDetail(GetOutpatientOrderDetailRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_OUTPATIENT_ORDER_DETAIL, getCallOptions(), request);
    }

    /**
     * <pre>
     * 根据 medical_id 获取诊疗卡信息
     * </pre>
     */
    public GetMedicalCardInfoByPatientIdResponse getMedicalCardInfoById(GetMedicalCardInfoByIdRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_MEDICAL_CARD_INFO_BY_ID, getCallOptions(), request);
    }

    /**
     * <pre>
     * 更新 outpatient order
     * </pre>
     */
    public UpdateOutpatientOrderResponse updateOutpatientOrder(UpdateOutpatientOrderRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_UPDATE_OUTPATIENT_ORDER, getCallOptions(), request);
    }

    /**
     * <pre>
     * 获取最近一次门诊缴费
     * </pre>
     */
    public GetLatestOutpatientOrderResponse getLatestOutpatientOrder(GetLatestOutpatientOrderRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_LATEST_OUTPATIENT_ORDER, getCallOptions(), request);
    }

    /**
     */
    public GetOutPatientConfigResponse getOutpatientConfigs(GetOutPatientConfigRequest request) {
      return blockingUnaryCall(
          getChannel(), METHOD_GET_OUTPATIENT_CONFIGS, getCallOptions(), request);
    }
  }

  /**
   * <pre>
   *太和门诊服务类    // 对应 taihe-service 项目的 TaiheOutpatientServiceImpl 类
   * </pre>
   */
  public static final class TaiheOutpatientServiceFutureStub extends io.grpc.stub.AbstractStub<TaiheOutpatientServiceFutureStub> {
    private TaiheOutpatientServiceFutureStub(io.grpc.Channel channel) {
      super(channel);
    }

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

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

    /**
     * <pre>
     *生成门诊缴费单
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<CreateOutpatientResponse> createOutpatient(
        CreateOutpatientRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_CREATE_OUTPATIENT, getCallOptions()), request);
    }

    /**
     * <pre>
     *订单支付成功通知
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<PayCallbackResponse> payCallback(
        PayCallbackRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_PAY_CALLBACK, getCallOptions()), request);
    }

    /**
     * <pre>
     *获取门诊缴费单二维码
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<GetOutpatientQrcodeResponse> getOutpatientQrcode(
        GetOutpatientQrcodeRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_QRCODE, getCallOptions()), request);
    }

    /**
     * <pre>
     *获取门诊缴费单详情
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<GetOutpatientDetailResponse> getOutpatientDetail(
        GetOutpatientDetailRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_DETAIL, getCallOptions()), request);
    }

    /**
     * <pre>
     *更新门诊单信息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<UpdateOutpatientResponse> updateOutpatient(
        UpdateOutpatientRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_UPDATE_OUTPATIENT, getCallOptions()), request);
    }

    /**
     * <pre>
     *门诊缴费订单退款回调
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<RefundOutpatientCallbackResponse> refundOutpatientCallback(
        RefundOutpatientCallbackRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_REFUND_OUTPATIENT_CALLBACK, getCallOptions()), request);
    }

    /**
     * <pre>
     *获取门诊缴费单列表
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<GetOutpatientListResponse> getOutpatientList(
        GetOutpatientListRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_LIST, getCallOptions()), request);
    }

    /**
     * <pre>
     * 根据 his_patient_id 获取诊疗卡信息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<GetMedicalCardInfoByPatientIdResponse> getMedicalCardInfoByPatientId(
        GetMedicalCardInfoByPatientIdRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID, getCallOptions()), request);
    }

    /**
     * <pre>
     * 根据 his_order_no 获取门诊订单信息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<GetOutpatientOrderByHisOrderNoResponse> getOutpatientOrderByHisOrderNo(
        GetOutpatientOrderByHisOrderNoRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO, getCallOptions()), request);
    }

    /**
     * <pre>
     * 保存门诊缴费订单明细
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<BaseResult> saveOutpatientOrderDetails(
        SaveOutpatientOrderDetailsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_SAVE_OUTPATIENT_ORDER_DETAILS, getCallOptions()), request);
    }

    /**
     * <pre>
     * 获取门诊缴费订单明细
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<GetOutpatientOrderDetailResponse> getOutpatientOrderDetail(
        GetOutpatientOrderDetailRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_ORDER_DETAIL, getCallOptions()), request);
    }

    /**
     * <pre>
     * 根据 medical_id 获取诊疗卡信息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<GetMedicalCardInfoByPatientIdResponse> getMedicalCardInfoById(
        GetMedicalCardInfoByIdRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_MEDICAL_CARD_INFO_BY_ID, getCallOptions()), request);
    }

    /**
     * <pre>
     * 更新 outpatient order
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<UpdateOutpatientOrderResponse> updateOutpatientOrder(
        UpdateOutpatientOrderRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_UPDATE_OUTPATIENT_ORDER, getCallOptions()), request);
    }

    /**
     * <pre>
     * 获取最近一次门诊缴费
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<GetLatestOutpatientOrderResponse> getLatestOutpatientOrder(
        GetLatestOutpatientOrderRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_LATEST_OUTPATIENT_ORDER, getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<GetOutPatientConfigResponse> getOutpatientConfigs(
        GetOutPatientConfigRequest request) {
      return futureUnaryCall(
          getChannel().newCall(METHOD_GET_OUTPATIENT_CONFIGS, getCallOptions()), request);
    }
  }

  private static final int METHODID_CREATE_OUTPATIENT = 0;
  private static final int METHODID_PAY_CALLBACK = 1;
  private static final int METHODID_GET_OUTPATIENT_QRCODE = 2;
  private static final int METHODID_GET_OUTPATIENT_DETAIL = 3;
  private static final int METHODID_UPDATE_OUTPATIENT = 4;
  private static final int METHODID_REFUND_OUTPATIENT_CALLBACK = 5;
  private static final int METHODID_GET_OUTPATIENT_LIST = 6;
  private static final int METHODID_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID = 7;
  private static final int METHODID_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO = 8;
  private static final int METHODID_SAVE_OUTPATIENT_ORDER_DETAILS = 9;
  private static final int METHODID_GET_OUTPATIENT_ORDER_DETAIL = 10;
  private static final int METHODID_GET_MEDICAL_CARD_INFO_BY_ID = 11;
  private static final int METHODID_UPDATE_OUTPATIENT_ORDER = 12;
  private static final int METHODID_GET_LATEST_OUTPATIENT_ORDER = 13;
  private static final int METHODID_GET_OUTPATIENT_CONFIGS = 14;

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

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

    @Override
    @SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_CREATE_OUTPATIENT:
          serviceImpl.createOutpatient((CreateOutpatientRequest) request,
              (io.grpc.stub.StreamObserver<CreateOutpatientResponse>) responseObserver);
          break;
        case METHODID_PAY_CALLBACK:
          serviceImpl.payCallback((PayCallbackRequest) request,
              (io.grpc.stub.StreamObserver<PayCallbackResponse>) responseObserver);
          break;
        case METHODID_GET_OUTPATIENT_QRCODE:
          serviceImpl.getOutpatientQrcode((GetOutpatientQrcodeRequest) request,
              (io.grpc.stub.StreamObserver<GetOutpatientQrcodeResponse>) responseObserver);
          break;
        case METHODID_GET_OUTPATIENT_DETAIL:
          serviceImpl.getOutpatientDetail((GetOutpatientDetailRequest) request,
              (io.grpc.stub.StreamObserver<GetOutpatientDetailResponse>) responseObserver);
          break;
        case METHODID_UPDATE_OUTPATIENT:
          serviceImpl.updateOutpatient((UpdateOutpatientRequest) request,
              (io.grpc.stub.StreamObserver<UpdateOutpatientResponse>) responseObserver);
          break;
        case METHODID_REFUND_OUTPATIENT_CALLBACK:
          serviceImpl.refundOutpatientCallback((RefundOutpatientCallbackRequest) request,
              (io.grpc.stub.StreamObserver<RefundOutpatientCallbackResponse>) responseObserver);
          break;
        case METHODID_GET_OUTPATIENT_LIST:
          serviceImpl.getOutpatientList((GetOutpatientListRequest) request,
              (io.grpc.stub.StreamObserver<GetOutpatientListResponse>) responseObserver);
          break;
        case METHODID_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID:
          serviceImpl.getMedicalCardInfoByPatientId((GetMedicalCardInfoByPatientIdRequest) request,
              (io.grpc.stub.StreamObserver<GetMedicalCardInfoByPatientIdResponse>) responseObserver);
          break;
        case METHODID_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO:
          serviceImpl.getOutpatientOrderByHisOrderNo((GetOutpatientOrderByHisOrderNoRequest) request,
              (io.grpc.stub.StreamObserver<GetOutpatientOrderByHisOrderNoResponse>) responseObserver);
          break;
        case METHODID_SAVE_OUTPATIENT_ORDER_DETAILS:
          serviceImpl.saveOutpatientOrderDetails((SaveOutpatientOrderDetailsRequest) request,
              (io.grpc.stub.StreamObserver<BaseResult>) responseObserver);
          break;
        case METHODID_GET_OUTPATIENT_ORDER_DETAIL:
          serviceImpl.getOutpatientOrderDetail((GetOutpatientOrderDetailRequest) request,
              (io.grpc.stub.StreamObserver<GetOutpatientOrderDetailResponse>) responseObserver);
          break;
        case METHODID_GET_MEDICAL_CARD_INFO_BY_ID:
          serviceImpl.getMedicalCardInfoById((GetMedicalCardInfoByIdRequest) request,
              (io.grpc.stub.StreamObserver<GetMedicalCardInfoByPatientIdResponse>) responseObserver);
          break;
        case METHODID_UPDATE_OUTPATIENT_ORDER:
          serviceImpl.updateOutpatientOrder((UpdateOutpatientOrderRequest) request,
              (io.grpc.stub.StreamObserver<UpdateOutpatientOrderResponse>) responseObserver);
          break;
        case METHODID_GET_LATEST_OUTPATIENT_ORDER:
          serviceImpl.getLatestOutpatientOrder((GetLatestOutpatientOrderRequest) request,
              (io.grpc.stub.StreamObserver<GetLatestOutpatientOrderResponse>) responseObserver);
          break;
        case METHODID_GET_OUTPATIENT_CONFIGS:
          serviceImpl.getOutpatientConfigs((GetOutPatientConfigRequest) request,
              (io.grpc.stub.StreamObserver<GetOutPatientConfigResponse>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @Override
    @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 TaiheOutpatientServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    TaiheOutpatientServiceBaseDescriptorSupplier() {}

    @Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return TaiheOutpatient.getDescriptor();
    }

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

  private static final class TaiheOutpatientServiceFileDescriptorSupplier
      extends TaiheOutpatientServiceBaseDescriptorSupplier {
    TaiheOutpatientServiceFileDescriptorSupplier() {}
  }

  private static final class TaiheOutpatientServiceMethodDescriptorSupplier
      extends TaiheOutpatientServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

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

    @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 (TaiheOutpatientServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new TaiheOutpatientServiceFileDescriptorSupplier())
              .addMethod(METHOD_CREATE_OUTPATIENT)
              .addMethod(METHOD_PAY_CALLBACK)
              .addMethod(METHOD_GET_OUTPATIENT_QRCODE)
              .addMethod(METHOD_GET_OUTPATIENT_DETAIL)
              .addMethod(METHOD_UPDATE_OUTPATIENT)
              .addMethod(METHOD_REFUND_OUTPATIENT_CALLBACK)
              .addMethod(METHOD_GET_OUTPATIENT_LIST)
              .addMethod(METHOD_GET_MEDICAL_CARD_INFO_BY_PATIENT_ID)
              .addMethod(METHOD_GET_OUTPATIENT_ORDER_BY_HIS_ORDER_NO)
              .addMethod(METHOD_SAVE_OUTPATIENT_ORDER_DETAILS)
              .addMethod(METHOD_GET_OUTPATIENT_ORDER_DETAIL)
              .addMethod(METHOD_GET_MEDICAL_CARD_INFO_BY_ID)
              .addMethod(METHOD_UPDATE_OUTPATIENT_ORDER)
              .addMethod(METHOD_GET_LATEST_OUTPATIENT_ORDER)
              .addMethod(METHOD_GET_OUTPATIENT_CONFIGS)
              .build();
        }
      }
    }
    return result;
  }
}
