/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

    package com.ywt.gapi.taihe.register;

import com.google.protobuf.Message;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.stream.StreamObserver;
import org.apache.dubbo.rpc.*;
import org.apache.dubbo.rpc.model.MethodDescriptor;
import org.apache.dubbo.rpc.model.ServiceDescriptor;
import org.apache.dubbo.rpc.model.StubMethodDescriptor;
import org.apache.dubbo.rpc.model.StubServiceDescriptor;
import org.apache.dubbo.rpc.stub.*;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiConsumer;

public final class DubboTaiheRegisterServiceTriple {

    public static final String SERVICE_NAME = TaiheRegisterService.SERVICE_NAME;

    private static final StubServiceDescriptor serviceDescriptor = new StubServiceDescriptor(SERVICE_NAME,TaiheRegisterService.class);

    static {
        org.apache.dubbo.rpc.protocol.tri.service.SchemaDescriptorRegistry.addSchemaDescriptor(SERVICE_NAME,TaiheRegisterProto.getDescriptor());
        StubSuppliers.addSupplier(SERVICE_NAME, DubboTaiheRegisterServiceTriple::newStub);
        StubSuppliers.addSupplier(TaiheRegisterService.JAVA_SERVICE_NAME,  DubboTaiheRegisterServiceTriple::newStub);
        StubSuppliers.addDescriptor(SERVICE_NAME, serviceDescriptor);
        StubSuppliers.addDescriptor(TaiheRegisterService.JAVA_SERVICE_NAME, serviceDescriptor);
    }

    @SuppressWarnings("all")
    public static TaiheRegisterService newStub(Invoker<?> invoker) {
        return new TaiheRegisterServiceStub((Invoker<TaiheRegisterService>)invoker);
    }

    /**
         * <pre>
         * 医生职称
         * </pre>
         */
    private static final StubMethodDescriptor createRegisteredMethod = new StubMethodDescriptor("createRegistered",
    CreateRegisteredRequest.class, CreateRegisteredResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), CreateRegisteredRequest::parseFrom,
    CreateRegisteredResponse::parseFrom);

    private static final StubMethodDescriptor createRegisteredAsyncMethod = new StubMethodDescriptor("createRegistered",
    CreateRegisteredRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), CreateRegisteredRequest::parseFrom,
    CreateRegisteredResponse::parseFrom);

    private static final StubMethodDescriptor createRegisteredProxyAsyncMethod = new StubMethodDescriptor("createRegisteredAsync",
    CreateRegisteredRequest.class, CreateRegisteredResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), CreateRegisteredRequest::parseFrom,
    CreateRegisteredResponse::parseFrom);

    /**
         * <pre>
         * 科室Code
         * </pre>
         */
    private static final StubMethodDescriptor cancelRegisteredMethod = new StubMethodDescriptor("cancelRegistered",
    com.ywt.gapi.taihe.register.CancelRegisteredRequest.class, com.ywt.gapi.taihe.register.CancelRegisteredResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.CancelRegisteredRequest::parseFrom,
    com.ywt.gapi.taihe.register.CancelRegisteredResponse::parseFrom);

    private static final StubMethodDescriptor cancelRegisteredAsyncMethod = new StubMethodDescriptor("cancelRegistered",
    com.ywt.gapi.taihe.register.CancelRegisteredRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.CancelRegisteredRequest::parseFrom,
    com.ywt.gapi.taihe.register.CancelRegisteredResponse::parseFrom);

    private static final StubMethodDescriptor cancelRegisteredProxyAsyncMethod = new StubMethodDescriptor("cancelRegisteredAsync",
    com.ywt.gapi.taihe.register.CancelRegisteredRequest.class, com.ywt.gapi.taihe.register.CancelRegisteredResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.CancelRegisteredRequest::parseFrom,
    com.ywt.gapi.taihe.register.CancelRegisteredResponse::parseFrom);

    /**
         * <pre>
         * 科室名称
         * </pre>
         */
    private static final StubMethodDescriptor payCallbackMethod = new StubMethodDescriptor("payCallback",
    PayCallbackRequest.class, PayCallbackResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), PayCallbackRequest::parseFrom,
    PayCallbackResponse::parseFrom);

    private static final StubMethodDescriptor payCallbackAsyncMethod = new StubMethodDescriptor("payCallback",
    PayCallbackRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), PayCallbackRequest::parseFrom,
    PayCallbackResponse::parseFrom);

    private static final StubMethodDescriptor payCallbackProxyAsyncMethod = new StubMethodDescriptor("payCallbackAsync",
    PayCallbackRequest.class, PayCallbackResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), PayCallbackRequest::parseFrom,
    PayCallbackResponse::parseFrom);

    /**
         * <pre>
         * 医生Code
         * </pre>
         */
    private static final StubMethodDescriptor refundCallbackMethod = new StubMethodDescriptor("refundCallback",
    RefundCallbackRequest.class, RefundCallbackResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), RefundCallbackRequest::parseFrom,
    RefundCallbackResponse::parseFrom);

    private static final StubMethodDescriptor refundCallbackAsyncMethod = new StubMethodDescriptor("refundCallback",
    RefundCallbackRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), RefundCallbackRequest::parseFrom,
    RefundCallbackResponse::parseFrom);

    private static final StubMethodDescriptor refundCallbackProxyAsyncMethod = new StubMethodDescriptor("refundCallbackAsync",
    RefundCallbackRequest.class, RefundCallbackResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), RefundCallbackRequest::parseFrom,
    RefundCallbackResponse::parseFrom);

    /**
         * <pre>
         * 医生名称
         * </pre>
         */
    private static final StubMethodDescriptor registerMethod = new StubMethodDescriptor("register",
    RegisterRequest.class, com.ywt.gapi.taihe.register.RegisterResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), RegisterRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterResponse::parseFrom);

    private static final StubMethodDescriptor registerAsyncMethod = new StubMethodDescriptor("register",
    RegisterRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), RegisterRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterResponse::parseFrom);

    private static final StubMethodDescriptor registerProxyAsyncMethod = new StubMethodDescriptor("registerAsync",
    RegisterRequest.class, com.ywt.gapi.taihe.register.RegisterResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), RegisterRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterResponse::parseFrom);

    /**
         * <pre>
         * 预约挂号总费用
         * </pre>
         */
    private static final StubMethodDescriptor takeMethod = new StubMethodDescriptor("take",
    TakeRequest.class, com.ywt.gapi.taihe.register.TakeResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), TakeRequest::parseFrom,
    com.ywt.gapi.taihe.register.TakeResponse::parseFrom);

    private static final StubMethodDescriptor takeAsyncMethod = new StubMethodDescriptor("take",
    TakeRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), TakeRequest::parseFrom,
    com.ywt.gapi.taihe.register.TakeResponse::parseFrom);

    private static final StubMethodDescriptor takeProxyAsyncMethod = new StubMethodDescriptor("takeAsync",
    TakeRequest.class, com.ywt.gapi.taihe.register.TakeResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), TakeRequest::parseFrom,
    com.ywt.gapi.taihe.register.TakeResponse::parseFrom);

    /**
         * <pre>
         * 挂号费
         * </pre>
         */
    private static final StubMethodDescriptor getQueueListMethod = new StubMethodDescriptor("getQueueList",
    GetQueueListRequest.class, GetQueueListResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetQueueListRequest::parseFrom,
    GetQueueListResponse::parseFrom);

    private static final StubMethodDescriptor getQueueListAsyncMethod = new StubMethodDescriptor("getQueueList",
    GetQueueListRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetQueueListRequest::parseFrom,
    GetQueueListResponse::parseFrom);

    private static final StubMethodDescriptor getQueueListProxyAsyncMethod = new StubMethodDescriptor("getQueueListAsync",
    GetQueueListRequest.class, GetQueueListResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetQueueListRequest::parseFrom,
    GetQueueListResponse::parseFrom);

    /**
         * <pre>
         * 诊查费
         * </pre>
         */
    private static final StubMethodDescriptor getCommonOrderListMethod = new StubMethodDescriptor("getCommonOrderList",
    GetCommonOrderListRequest.class, GetCommonOrderListResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetCommonOrderListRequest::parseFrom,
    GetCommonOrderListResponse::parseFrom);

    private static final StubMethodDescriptor getCommonOrderListAsyncMethod = new StubMethodDescriptor("getCommonOrderList",
    GetCommonOrderListRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetCommonOrderListRequest::parseFrom,
    GetCommonOrderListResponse::parseFrom);

    private static final StubMethodDescriptor getCommonOrderListProxyAsyncMethod = new StubMethodDescriptor("getCommonOrderListAsync",
    GetCommonOrderListRequest.class, GetCommonOrderListResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetCommonOrderListRequest::parseFrom,
    GetCommonOrderListResponse::parseFrom);

    /**
         * <pre>
         * 预约日期
         * </pre>
         */
    private static final StubMethodDescriptor getRegisteredListMethod = new StubMethodDescriptor("getRegisteredList",
    GetRegisteredListRequest.class, GetRegisteredListResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetRegisteredListRequest::parseFrom,
    GetRegisteredListResponse::parseFrom);

    private static final StubMethodDescriptor getRegisteredListAsyncMethod = new StubMethodDescriptor("getRegisteredList",
    GetRegisteredListRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetRegisteredListRequest::parseFrom,
    GetRegisteredListResponse::parseFrom);

    private static final StubMethodDescriptor getRegisteredListProxyAsyncMethod = new StubMethodDescriptor("getRegisteredListAsync",
    GetRegisteredListRequest.class, GetRegisteredListResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetRegisteredListRequest::parseFrom,
    GetRegisteredListResponse::parseFrom);

    /**
         * <pre>
         * 预约时间段
         * </pre>
         */
    private static final StubMethodDescriptor registerWithoutMedicalCardMethod = new StubMethodDescriptor("registerWithoutMedicalCard",
    com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest.class, com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse::parseFrom);

    private static final StubMethodDescriptor registerWithoutMedicalCardAsyncMethod = new StubMethodDescriptor("registerWithoutMedicalCard",
    com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse::parseFrom);

    private static final StubMethodDescriptor registerWithoutMedicalCardProxyAsyncMethod = new StubMethodDescriptor("registerWithoutMedicalCardAsync",
    com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest.class, com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse::parseFrom);

    /**
         * <pre>
         * 预约开始时间：HH:MI
         * </pre>
         */
    private static final StubMethodDescriptor getOfflineConsultInfoByDoctorIdMethod = new StubMethodDescriptor("getOfflineConsultInfoByDoctorId",
    GetOfflineConsultInfoByDoctorIdRequest.class, GetOfflineConsultInfoByDoctorIdResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetOfflineConsultInfoByDoctorIdRequest::parseFrom,
    GetOfflineConsultInfoByDoctorIdResponse::parseFrom);

    private static final StubMethodDescriptor getOfflineConsultInfoByDoctorIdAsyncMethod = new StubMethodDescriptor("getOfflineConsultInfoByDoctorId",
    GetOfflineConsultInfoByDoctorIdRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetOfflineConsultInfoByDoctorIdRequest::parseFrom,
    GetOfflineConsultInfoByDoctorIdResponse::parseFrom);

    private static final StubMethodDescriptor getOfflineConsultInfoByDoctorIdProxyAsyncMethod = new StubMethodDescriptor("getOfflineConsultInfoByDoctorIdAsync",
    GetOfflineConsultInfoByDoctorIdRequest.class, GetOfflineConsultInfoByDoctorIdResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetOfflineConsultInfoByDoctorIdRequest::parseFrom,
    GetOfflineConsultInfoByDoctorIdResponse::parseFrom);

    /**
         * <pre>
         * 预约结束时间：HH:MI
         * </pre>
         */
    private static final StubMethodDescriptor getLatestRegOrderMethod = new StubMethodDescriptor("getLatestRegOrder",
    GetLatestRegOrderRequest.class, GetLatestRegOrderResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetLatestRegOrderRequest::parseFrom,
    GetLatestRegOrderResponse::parseFrom);

    private static final StubMethodDescriptor getLatestRegOrderAsyncMethod = new StubMethodDescriptor("getLatestRegOrder",
    GetLatestRegOrderRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetLatestRegOrderRequest::parseFrom,
    GetLatestRegOrderResponse::parseFrom);

    private static final StubMethodDescriptor getLatestRegOrderProxyAsyncMethod = new StubMethodDescriptor("getLatestRegOrderAsync",
    GetLatestRegOrderRequest.class, GetLatestRegOrderResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), GetLatestRegOrderRequest::parseFrom,
    GetLatestRegOrderResponse::parseFrom);

    /**
         * <pre>
         * 用户ID
         * </pre>
         */
    private static final StubMethodDescriptor calAdditionalFeeMethod = new StubMethodDescriptor("calAdditionalFee",
    CalAdditionalFeeRequest.class, com.ywt.gapi.taihe.register.CalAdditionalFeeResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), CalAdditionalFeeRequest::parseFrom,
    com.ywt.gapi.taihe.register.CalAdditionalFeeResponse::parseFrom);

    private static final StubMethodDescriptor calAdditionalFeeAsyncMethod = new StubMethodDescriptor("calAdditionalFee",
    CalAdditionalFeeRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), CalAdditionalFeeRequest::parseFrom,
    com.ywt.gapi.taihe.register.CalAdditionalFeeResponse::parseFrom);

    private static final StubMethodDescriptor calAdditionalFeeProxyAsyncMethod = new StubMethodDescriptor("calAdditionalFeeAsync",
    CalAdditionalFeeRequest.class, com.ywt.gapi.taihe.register.CalAdditionalFeeResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), CalAdditionalFeeRequest::parseFrom,
    com.ywt.gapi.taihe.register.CalAdditionalFeeResponse::parseFrom);

    /**
         * <pre>
         * 诊疗卡ID
         * </pre>
         */
    private static final StubMethodDescriptor getHisPatientIdByUserIdAndMobileMethod = new StubMethodDescriptor("getHisPatientIdByUserIdAndMobile",
    com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest.class, GetHisPatientIdByUserIdAndMobileResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest::parseFrom,
    GetHisPatientIdByUserIdAndMobileResponse::parseFrom);

    private static final StubMethodDescriptor getHisPatientIdByUserIdAndMobileAsyncMethod = new StubMethodDescriptor("getHisPatientIdByUserIdAndMobile",
    com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest::parseFrom,
    GetHisPatientIdByUserIdAndMobileResponse::parseFrom);

    private static final StubMethodDescriptor getHisPatientIdByUserIdAndMobileProxyAsyncMethod = new StubMethodDescriptor("getHisPatientIdByUserIdAndMobileAsync",
    com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest.class, GetHisPatientIdByUserIdAndMobileResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest::parseFrom,
    GetHisPatientIdByUserIdAndMobileResponse::parseFrom);

    /**
         * <pre>
         * 门诊排班项记录标识
         * </pre>
         */
    private static final StubMethodDescriptor createMedicalCardMethod = new StubMethodDescriptor("createMedicalCard",
    com.ywt.gapi.taihe.register.CreateMedicalCardRequest.class, CreateMedicalCardResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.CreateMedicalCardRequest::parseFrom,
    CreateMedicalCardResponse::parseFrom);

    private static final StubMethodDescriptor createMedicalCardAsyncMethod = new StubMethodDescriptor("createMedicalCard",
    com.ywt.gapi.taihe.register.CreateMedicalCardRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.CreateMedicalCardRequest::parseFrom,
    CreateMedicalCardResponse::parseFrom);

    private static final StubMethodDescriptor createMedicalCardProxyAsyncMethod = new StubMethodDescriptor("createMedicalCardAsync",
    com.ywt.gapi.taihe.register.CreateMedicalCardRequest.class, CreateMedicalCardResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.CreateMedicalCardRequest::parseFrom,
    CreateMedicalCardResponse::parseFrom);

    /**
         * <pre>
         * 支付渠道
         * </pre>
         */
    private static final StubMethodDescriptor registerCheckInMessageMethod = new StubMethodDescriptor("registerCheckInMessage",
    com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest.class, com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse::parseFrom);

    private static final StubMethodDescriptor registerCheckInMessageAsyncMethod = new StubMethodDescriptor("registerCheckInMessage",
    com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest.class, CompletableFuture.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse::parseFrom);

    private static final StubMethodDescriptor registerCheckInMessageProxyAsyncMethod = new StubMethodDescriptor("registerCheckInMessageAsync",
    com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest.class, com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse.class, serviceDescriptor, MethodDescriptor.RpcType.UNARY,
    obj -> ((Message) obj).toByteArray(), obj -> ((Message) obj).toByteArray(), com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest::parseFrom,
    com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse::parseFrom);





    public static class TaiheRegisterServiceStub implements TaiheRegisterService{
        private final Invoker<TaiheRegisterService> invoker;

        public TaiheRegisterServiceStub(Invoker<TaiheRegisterService> invoker) {
            this.invoker = invoker;
        }

            /**
         * <pre>
         * 医生职称
         * </pre>
         */
        @Override
        public CreateRegisteredResponse createRegistered(CreateRegisteredRequest request){
            return StubInvocationUtil.unaryCall(invoker, createRegisteredMethod, request);
        }

        public CompletableFuture<CreateRegisteredResponse> createRegisteredAsync(CreateRegisteredRequest request){
            return StubInvocationUtil.unaryCall(invoker, createRegisteredAsyncMethod, request);
        }

            /**
         * <pre>
         * 医生职称
         * </pre>
         */
        @Override
        public void createRegistered(CreateRegisteredRequest request, StreamObserver<CreateRegisteredResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, createRegisteredMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 科室Code
         * </pre>
         */
        @Override
        public com.ywt.gapi.taihe.register.CancelRegisteredResponse cancelRegistered(com.ywt.gapi.taihe.register.CancelRegisteredRequest request){
            return StubInvocationUtil.unaryCall(invoker, cancelRegisteredMethod, request);
        }

        public CompletableFuture<com.ywt.gapi.taihe.register.CancelRegisteredResponse> cancelRegisteredAsync(com.ywt.gapi.taihe.register.CancelRegisteredRequest request){
            return StubInvocationUtil.unaryCall(invoker, cancelRegisteredAsyncMethod, request);
        }

            /**
         * <pre>
         * 科室Code
         * </pre>
         */
        @Override
        public void cancelRegistered(com.ywt.gapi.taihe.register.CancelRegisteredRequest request, StreamObserver<com.ywt.gapi.taihe.register.CancelRegisteredResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, cancelRegisteredMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 科室名称
         * </pre>
         */
        @Override
        public PayCallbackResponse payCallback(PayCallbackRequest request){
            return StubInvocationUtil.unaryCall(invoker, payCallbackMethod, request);
        }

        public CompletableFuture<PayCallbackResponse> payCallbackAsync(PayCallbackRequest request){
            return StubInvocationUtil.unaryCall(invoker, payCallbackAsyncMethod, request);
        }

            /**
         * <pre>
         * 科室名称
         * </pre>
         */
        @Override
        public void payCallback(PayCallbackRequest request, StreamObserver<PayCallbackResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, payCallbackMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 医生Code
         * </pre>
         */
        @Override
        public RefundCallbackResponse refundCallback(RefundCallbackRequest request){
            return StubInvocationUtil.unaryCall(invoker, refundCallbackMethod, request);
        }

        public CompletableFuture<RefundCallbackResponse> refundCallbackAsync(RefundCallbackRequest request){
            return StubInvocationUtil.unaryCall(invoker, refundCallbackAsyncMethod, request);
        }

            /**
         * <pre>
         * 医生Code
         * </pre>
         */
        @Override
        public void refundCallback(RefundCallbackRequest request, StreamObserver<RefundCallbackResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, refundCallbackMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 医生名称
         * </pre>
         */
        @Override
        public com.ywt.gapi.taihe.register.RegisterResponse register(RegisterRequest request){
            return StubInvocationUtil.unaryCall(invoker, registerMethod, request);
        }

        public CompletableFuture<com.ywt.gapi.taihe.register.RegisterResponse> registerAsync(RegisterRequest request){
            return StubInvocationUtil.unaryCall(invoker, registerAsyncMethod, request);
        }

            /**
         * <pre>
         * 医生名称
         * </pre>
         */
        @Override
        public void register(RegisterRequest request, StreamObserver<com.ywt.gapi.taihe.register.RegisterResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, registerMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 预约挂号总费用
         * </pre>
         */
        @Override
        public com.ywt.gapi.taihe.register.TakeResponse take(TakeRequest request){
            return StubInvocationUtil.unaryCall(invoker, takeMethod, request);
        }

        public CompletableFuture<com.ywt.gapi.taihe.register.TakeResponse> takeAsync(TakeRequest request){
            return StubInvocationUtil.unaryCall(invoker, takeAsyncMethod, request);
        }

            /**
         * <pre>
         * 预约挂号总费用
         * </pre>
         */
        @Override
        public void take(TakeRequest request, StreamObserver<com.ywt.gapi.taihe.register.TakeResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, takeMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 挂号费
         * </pre>
         */
        @Override
        public GetQueueListResponse getQueueList(GetQueueListRequest request){
            return StubInvocationUtil.unaryCall(invoker, getQueueListMethod, request);
        }

        public CompletableFuture<GetQueueListResponse> getQueueListAsync(GetQueueListRequest request){
            return StubInvocationUtil.unaryCall(invoker, getQueueListAsyncMethod, request);
        }

            /**
         * <pre>
         * 挂号费
         * </pre>
         */
        @Override
        public void getQueueList(GetQueueListRequest request, StreamObserver<GetQueueListResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, getQueueListMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 诊查费
         * </pre>
         */
        @Override
        public GetCommonOrderListResponse getCommonOrderList(GetCommonOrderListRequest request){
            return StubInvocationUtil.unaryCall(invoker, getCommonOrderListMethod, request);
        }

        public CompletableFuture<GetCommonOrderListResponse> getCommonOrderListAsync(GetCommonOrderListRequest request){
            return StubInvocationUtil.unaryCall(invoker, getCommonOrderListAsyncMethod, request);
        }

            /**
         * <pre>
         * 诊查费
         * </pre>
         */
        @Override
        public void getCommonOrderList(GetCommonOrderListRequest request, StreamObserver<GetCommonOrderListResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, getCommonOrderListMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 预约日期
         * </pre>
         */
        @Override
        public GetRegisteredListResponse getRegisteredList(GetRegisteredListRequest request){
            return StubInvocationUtil.unaryCall(invoker, getRegisteredListMethod, request);
        }

        public CompletableFuture<GetRegisteredListResponse> getRegisteredListAsync(GetRegisteredListRequest request){
            return StubInvocationUtil.unaryCall(invoker, getRegisteredListAsyncMethod, request);
        }

            /**
         * <pre>
         * 预约日期
         * </pre>
         */
        @Override
        public void getRegisteredList(GetRegisteredListRequest request, StreamObserver<GetRegisteredListResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, getRegisteredListMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 预约时间段
         * </pre>
         */
        @Override
        public com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse registerWithoutMedicalCard(com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest request){
            return StubInvocationUtil.unaryCall(invoker, registerWithoutMedicalCardMethod, request);
        }

        public CompletableFuture<com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse> registerWithoutMedicalCardAsync(com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest request){
            return StubInvocationUtil.unaryCall(invoker, registerWithoutMedicalCardAsyncMethod, request);
        }

            /**
         * <pre>
         * 预约时间段
         * </pre>
         */
        @Override
        public void registerWithoutMedicalCard(com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest request, StreamObserver<com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, registerWithoutMedicalCardMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 预约开始时间：HH:MI
         * </pre>
         */
        @Override
        public GetOfflineConsultInfoByDoctorIdResponse getOfflineConsultInfoByDoctorId(GetOfflineConsultInfoByDoctorIdRequest request){
            return StubInvocationUtil.unaryCall(invoker, getOfflineConsultInfoByDoctorIdMethod, request);
        }

        public CompletableFuture<GetOfflineConsultInfoByDoctorIdResponse> getOfflineConsultInfoByDoctorIdAsync(GetOfflineConsultInfoByDoctorIdRequest request){
            return StubInvocationUtil.unaryCall(invoker, getOfflineConsultInfoByDoctorIdAsyncMethod, request);
        }

            /**
         * <pre>
         * 预约开始时间：HH:MI
         * </pre>
         */
        @Override
        public void getOfflineConsultInfoByDoctorId(GetOfflineConsultInfoByDoctorIdRequest request, StreamObserver<GetOfflineConsultInfoByDoctorIdResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, getOfflineConsultInfoByDoctorIdMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 预约结束时间：HH:MI
         * </pre>
         */
        @Override
        public GetLatestRegOrderResponse getLatestRegOrder(GetLatestRegOrderRequest request){
            return StubInvocationUtil.unaryCall(invoker, getLatestRegOrderMethod, request);
        }

        public CompletableFuture<GetLatestRegOrderResponse> getLatestRegOrderAsync(GetLatestRegOrderRequest request){
            return StubInvocationUtil.unaryCall(invoker, getLatestRegOrderAsyncMethod, request);
        }

            /**
         * <pre>
         * 预约结束时间：HH:MI
         * </pre>
         */
        @Override
        public void getLatestRegOrder(GetLatestRegOrderRequest request, StreamObserver<GetLatestRegOrderResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, getLatestRegOrderMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 用户ID
         * </pre>
         */
        @Override
        public com.ywt.gapi.taihe.register.CalAdditionalFeeResponse calAdditionalFee(CalAdditionalFeeRequest request){
            return StubInvocationUtil.unaryCall(invoker, calAdditionalFeeMethod, request);
        }

        public CompletableFuture<com.ywt.gapi.taihe.register.CalAdditionalFeeResponse> calAdditionalFeeAsync(CalAdditionalFeeRequest request){
            return StubInvocationUtil.unaryCall(invoker, calAdditionalFeeAsyncMethod, request);
        }

            /**
         * <pre>
         * 用户ID
         * </pre>
         */
        @Override
        public void calAdditionalFee(CalAdditionalFeeRequest request, StreamObserver<com.ywt.gapi.taihe.register.CalAdditionalFeeResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, calAdditionalFeeMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 诊疗卡ID
         * </pre>
         */
        @Override
        public GetHisPatientIdByUserIdAndMobileResponse getHisPatientIdByUserIdAndMobile(com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest request){
            return StubInvocationUtil.unaryCall(invoker, getHisPatientIdByUserIdAndMobileMethod, request);
        }

        public CompletableFuture<GetHisPatientIdByUserIdAndMobileResponse> getHisPatientIdByUserIdAndMobileAsync(com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest request){
            return StubInvocationUtil.unaryCall(invoker, getHisPatientIdByUserIdAndMobileAsyncMethod, request);
        }

            /**
         * <pre>
         * 诊疗卡ID
         * </pre>
         */
        @Override
        public void getHisPatientIdByUserIdAndMobile(com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest request, StreamObserver<GetHisPatientIdByUserIdAndMobileResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, getHisPatientIdByUserIdAndMobileMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 门诊排班项记录标识
         * </pre>
         */
        @Override
        public CreateMedicalCardResponse createMedicalCard(com.ywt.gapi.taihe.register.CreateMedicalCardRequest request){
            return StubInvocationUtil.unaryCall(invoker, createMedicalCardMethod, request);
        }

        public CompletableFuture<CreateMedicalCardResponse> createMedicalCardAsync(com.ywt.gapi.taihe.register.CreateMedicalCardRequest request){
            return StubInvocationUtil.unaryCall(invoker, createMedicalCardAsyncMethod, request);
        }

            /**
         * <pre>
         * 门诊排班项记录标识
         * </pre>
         */
        @Override
        public void createMedicalCard(com.ywt.gapi.taihe.register.CreateMedicalCardRequest request, StreamObserver<CreateMedicalCardResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, createMedicalCardMethod , request, responseObserver);
        }
            /**
         * <pre>
         * 支付渠道
         * </pre>
         */
        @Override
        public com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse registerCheckInMessage(com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest request){
            return StubInvocationUtil.unaryCall(invoker, registerCheckInMessageMethod, request);
        }

        public CompletableFuture<com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse> registerCheckInMessageAsync(com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest request){
            return StubInvocationUtil.unaryCall(invoker, registerCheckInMessageAsyncMethod, request);
        }

            /**
         * <pre>
         * 支付渠道
         * </pre>
         */
        @Override
        public void registerCheckInMessage(com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest request, StreamObserver<com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse> responseObserver){
            StubInvocationUtil.unaryCall(invoker, registerCheckInMessageMethod , request, responseObserver);
        }



    }

    public static abstract class TaiheRegisterServiceImplBase implements TaiheRegisterService, ServerService<TaiheRegisterService> {

        private <T, R> BiConsumer<T, StreamObserver<R>> syncToAsync(java.util.function.Function<T, R> syncFun) {
            return new BiConsumer<T, StreamObserver<R>>() {
                @Override
                public void accept(T t, StreamObserver<R> observer) {
                    try {
                        R ret = syncFun.apply(t);
                        observer.onNext(ret);
                        observer.onCompleted();
                    } catch (Throwable e) {
                        observer.onError(e);
                    }
                }
            };
        }

        @Override
        public final Invoker<TaiheRegisterService> getInvoker(URL url) {
            PathResolver pathResolver = url.getOrDefaultFrameworkModel()
            .getExtensionLoader(PathResolver.class)
            .getDefaultExtension();
            Map<String,StubMethodHandler<?, ?>> handlers = new HashMap<>();

            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/createRegistered" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/createRegisteredAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/cancelRegistered" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/cancelRegisteredAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/payCallback" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/payCallbackAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/refundCallback" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/refundCallbackAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/register" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/registerAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/take" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/takeAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getQueueList" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getQueueListAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getCommonOrderList" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getCommonOrderListAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getRegisteredList" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getRegisteredListAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/registerWithoutMedicalCard" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/registerWithoutMedicalCardAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getOfflineConsultInfoByDoctorId" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getOfflineConsultInfoByDoctorIdAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getLatestRegOrder" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getLatestRegOrderAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/calAdditionalFee" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/calAdditionalFeeAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getHisPatientIdByUserIdAndMobile" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/getHisPatientIdByUserIdAndMobileAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/createMedicalCard" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/createMedicalCardAsync" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/registerCheckInMessage" );
            pathResolver.addNativeStub( "/" + SERVICE_NAME + "/registerCheckInMessageAsync" );

            BiConsumer<CreateRegisteredRequest, StreamObserver<CreateRegisteredResponse>> createRegisteredFunc = this::createRegistered;
            handlers.put(createRegisteredMethod.getMethodName(), new UnaryStubMethodHandler<>(createRegisteredFunc));
            BiConsumer<CreateRegisteredRequest, StreamObserver<CreateRegisteredResponse>> createRegisteredAsyncFunc = syncToAsync(this::createRegistered);
            handlers.put(createRegisteredProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(createRegisteredAsyncFunc));
            BiConsumer<com.ywt.gapi.taihe.register.CancelRegisteredRequest, StreamObserver<com.ywt.gapi.taihe.register.CancelRegisteredResponse>> cancelRegisteredFunc = this::cancelRegistered;
            handlers.put(cancelRegisteredMethod.getMethodName(), new UnaryStubMethodHandler<>(cancelRegisteredFunc));
            BiConsumer<com.ywt.gapi.taihe.register.CancelRegisteredRequest, StreamObserver<com.ywt.gapi.taihe.register.CancelRegisteredResponse>> cancelRegisteredAsyncFunc = syncToAsync(this::cancelRegistered);
            handlers.put(cancelRegisteredProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(cancelRegisteredAsyncFunc));
            BiConsumer<PayCallbackRequest, StreamObserver<PayCallbackResponse>> payCallbackFunc = this::payCallback;
            handlers.put(payCallbackMethod.getMethodName(), new UnaryStubMethodHandler<>(payCallbackFunc));
            BiConsumer<PayCallbackRequest, StreamObserver<PayCallbackResponse>> payCallbackAsyncFunc = syncToAsync(this::payCallback);
            handlers.put(payCallbackProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(payCallbackAsyncFunc));
            BiConsumer<RefundCallbackRequest, StreamObserver<RefundCallbackResponse>> refundCallbackFunc = this::refundCallback;
            handlers.put(refundCallbackMethod.getMethodName(), new UnaryStubMethodHandler<>(refundCallbackFunc));
            BiConsumer<RefundCallbackRequest, StreamObserver<RefundCallbackResponse>> refundCallbackAsyncFunc = syncToAsync(this::refundCallback);
            handlers.put(refundCallbackProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(refundCallbackAsyncFunc));
            BiConsumer<RegisterRequest, StreamObserver<com.ywt.gapi.taihe.register.RegisterResponse>> registerFunc = this::register;
            handlers.put(registerMethod.getMethodName(), new UnaryStubMethodHandler<>(registerFunc));
            BiConsumer<RegisterRequest, StreamObserver<com.ywt.gapi.taihe.register.RegisterResponse>> registerAsyncFunc = syncToAsync(this::register);
            handlers.put(registerProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(registerAsyncFunc));
            BiConsumer<TakeRequest, StreamObserver<com.ywt.gapi.taihe.register.TakeResponse>> takeFunc = this::take;
            handlers.put(takeMethod.getMethodName(), new UnaryStubMethodHandler<>(takeFunc));
            BiConsumer<TakeRequest, StreamObserver<com.ywt.gapi.taihe.register.TakeResponse>> takeAsyncFunc = syncToAsync(this::take);
            handlers.put(takeProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(takeAsyncFunc));
            BiConsumer<GetQueueListRequest, StreamObserver<GetQueueListResponse>> getQueueListFunc = this::getQueueList;
            handlers.put(getQueueListMethod.getMethodName(), new UnaryStubMethodHandler<>(getQueueListFunc));
            BiConsumer<GetQueueListRequest, StreamObserver<GetQueueListResponse>> getQueueListAsyncFunc = syncToAsync(this::getQueueList);
            handlers.put(getQueueListProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(getQueueListAsyncFunc));
            BiConsumer<GetCommonOrderListRequest, StreamObserver<GetCommonOrderListResponse>> getCommonOrderListFunc = this::getCommonOrderList;
            handlers.put(getCommonOrderListMethod.getMethodName(), new UnaryStubMethodHandler<>(getCommonOrderListFunc));
            BiConsumer<GetCommonOrderListRequest, StreamObserver<GetCommonOrderListResponse>> getCommonOrderListAsyncFunc = syncToAsync(this::getCommonOrderList);
            handlers.put(getCommonOrderListProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(getCommonOrderListAsyncFunc));
            BiConsumer<GetRegisteredListRequest, StreamObserver<GetRegisteredListResponse>> getRegisteredListFunc = this::getRegisteredList;
            handlers.put(getRegisteredListMethod.getMethodName(), new UnaryStubMethodHandler<>(getRegisteredListFunc));
            BiConsumer<GetRegisteredListRequest, StreamObserver<GetRegisteredListResponse>> getRegisteredListAsyncFunc = syncToAsync(this::getRegisteredList);
            handlers.put(getRegisteredListProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(getRegisteredListAsyncFunc));
            BiConsumer<com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest, StreamObserver<com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse>> registerWithoutMedicalCardFunc = this::registerWithoutMedicalCard;
            handlers.put(registerWithoutMedicalCardMethod.getMethodName(), new UnaryStubMethodHandler<>(registerWithoutMedicalCardFunc));
            BiConsumer<com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest, StreamObserver<com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse>> registerWithoutMedicalCardAsyncFunc = syncToAsync(this::registerWithoutMedicalCard);
            handlers.put(registerWithoutMedicalCardProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(registerWithoutMedicalCardAsyncFunc));
            BiConsumer<GetOfflineConsultInfoByDoctorIdRequest, StreamObserver<GetOfflineConsultInfoByDoctorIdResponse>> getOfflineConsultInfoByDoctorIdFunc = this::getOfflineConsultInfoByDoctorId;
            handlers.put(getOfflineConsultInfoByDoctorIdMethod.getMethodName(), new UnaryStubMethodHandler<>(getOfflineConsultInfoByDoctorIdFunc));
            BiConsumer<GetOfflineConsultInfoByDoctorIdRequest, StreamObserver<GetOfflineConsultInfoByDoctorIdResponse>> getOfflineConsultInfoByDoctorIdAsyncFunc = syncToAsync(this::getOfflineConsultInfoByDoctorId);
            handlers.put(getOfflineConsultInfoByDoctorIdProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(getOfflineConsultInfoByDoctorIdAsyncFunc));
            BiConsumer<GetLatestRegOrderRequest, StreamObserver<GetLatestRegOrderResponse>> getLatestRegOrderFunc = this::getLatestRegOrder;
            handlers.put(getLatestRegOrderMethod.getMethodName(), new UnaryStubMethodHandler<>(getLatestRegOrderFunc));
            BiConsumer<GetLatestRegOrderRequest, StreamObserver<GetLatestRegOrderResponse>> getLatestRegOrderAsyncFunc = syncToAsync(this::getLatestRegOrder);
            handlers.put(getLatestRegOrderProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(getLatestRegOrderAsyncFunc));
            BiConsumer<CalAdditionalFeeRequest, StreamObserver<com.ywt.gapi.taihe.register.CalAdditionalFeeResponse>> calAdditionalFeeFunc = this::calAdditionalFee;
            handlers.put(calAdditionalFeeMethod.getMethodName(), new UnaryStubMethodHandler<>(calAdditionalFeeFunc));
            BiConsumer<CalAdditionalFeeRequest, StreamObserver<com.ywt.gapi.taihe.register.CalAdditionalFeeResponse>> calAdditionalFeeAsyncFunc = syncToAsync(this::calAdditionalFee);
            handlers.put(calAdditionalFeeProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(calAdditionalFeeAsyncFunc));
            BiConsumer<com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest, StreamObserver<GetHisPatientIdByUserIdAndMobileResponse>> getHisPatientIdByUserIdAndMobileFunc = this::getHisPatientIdByUserIdAndMobile;
            handlers.put(getHisPatientIdByUserIdAndMobileMethod.getMethodName(), new UnaryStubMethodHandler<>(getHisPatientIdByUserIdAndMobileFunc));
            BiConsumer<com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest, StreamObserver<GetHisPatientIdByUserIdAndMobileResponse>> getHisPatientIdByUserIdAndMobileAsyncFunc = syncToAsync(this::getHisPatientIdByUserIdAndMobile);
            handlers.put(getHisPatientIdByUserIdAndMobileProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(getHisPatientIdByUserIdAndMobileAsyncFunc));
            BiConsumer<com.ywt.gapi.taihe.register.CreateMedicalCardRequest, StreamObserver<CreateMedicalCardResponse>> createMedicalCardFunc = this::createMedicalCard;
            handlers.put(createMedicalCardMethod.getMethodName(), new UnaryStubMethodHandler<>(createMedicalCardFunc));
            BiConsumer<com.ywt.gapi.taihe.register.CreateMedicalCardRequest, StreamObserver<CreateMedicalCardResponse>> createMedicalCardAsyncFunc = syncToAsync(this::createMedicalCard);
            handlers.put(createMedicalCardProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(createMedicalCardAsyncFunc));
            BiConsumer<com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest, StreamObserver<com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse>> registerCheckInMessageFunc = this::registerCheckInMessage;
            handlers.put(registerCheckInMessageMethod.getMethodName(), new UnaryStubMethodHandler<>(registerCheckInMessageFunc));
            BiConsumer<com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest, StreamObserver<com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse>> registerCheckInMessageAsyncFunc = syncToAsync(this::registerCheckInMessage);
            handlers.put(registerCheckInMessageProxyAsyncMethod.getMethodName(), new UnaryStubMethodHandler<>(registerCheckInMessageAsyncFunc));




            return new StubInvoker<>(this, url, TaiheRegisterService.class, handlers);
        }


        @Override
        public CreateRegisteredResponse createRegistered(CreateRegisteredRequest request){
            throw unimplementedMethodException(createRegisteredMethod);
        }

        @Override
        public com.ywt.gapi.taihe.register.CancelRegisteredResponse cancelRegistered(com.ywt.gapi.taihe.register.CancelRegisteredRequest request){
            throw unimplementedMethodException(cancelRegisteredMethod);
        }

        @Override
        public PayCallbackResponse payCallback(PayCallbackRequest request){
            throw unimplementedMethodException(payCallbackMethod);
        }

        @Override
        public RefundCallbackResponse refundCallback(RefundCallbackRequest request){
            throw unimplementedMethodException(refundCallbackMethod);
        }

        @Override
        public com.ywt.gapi.taihe.register.RegisterResponse register(RegisterRequest request){
            throw unimplementedMethodException(registerMethod);
        }

        @Override
        public com.ywt.gapi.taihe.register.TakeResponse take(TakeRequest request){
            throw unimplementedMethodException(takeMethod);
        }

        @Override
        public GetQueueListResponse getQueueList(GetQueueListRequest request){
            throw unimplementedMethodException(getQueueListMethod);
        }

        @Override
        public GetCommonOrderListResponse getCommonOrderList(GetCommonOrderListRequest request){
            throw unimplementedMethodException(getCommonOrderListMethod);
        }

        @Override
        public GetRegisteredListResponse getRegisteredList(GetRegisteredListRequest request){
            throw unimplementedMethodException(getRegisteredListMethod);
        }

        @Override
        public com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardResponse registerWithoutMedicalCard(com.ywt.gapi.taihe.register.RegisterWithoutMedicalCardRequest request){
            throw unimplementedMethodException(registerWithoutMedicalCardMethod);
        }

        @Override
        public GetOfflineConsultInfoByDoctorIdResponse getOfflineConsultInfoByDoctorId(GetOfflineConsultInfoByDoctorIdRequest request){
            throw unimplementedMethodException(getOfflineConsultInfoByDoctorIdMethod);
        }

        @Override
        public GetLatestRegOrderResponse getLatestRegOrder(GetLatestRegOrderRequest request){
            throw unimplementedMethodException(getLatestRegOrderMethod);
        }

        @Override
        public com.ywt.gapi.taihe.register.CalAdditionalFeeResponse calAdditionalFee(CalAdditionalFeeRequest request){
            throw unimplementedMethodException(calAdditionalFeeMethod);
        }

        @Override
        public GetHisPatientIdByUserIdAndMobileResponse getHisPatientIdByUserIdAndMobile(com.ywt.gapi.taihe.register.GetHisPatientIdByUserIdAndMobileRequest request){
            throw unimplementedMethodException(getHisPatientIdByUserIdAndMobileMethod);
        }

        @Override
        public CreateMedicalCardResponse createMedicalCard(com.ywt.gapi.taihe.register.CreateMedicalCardRequest request){
            throw unimplementedMethodException(createMedicalCardMethod);
        }

        @Override
        public com.ywt.gapi.taihe.register.RegisterCheckInMessageResponse registerCheckInMessage(com.ywt.gapi.taihe.register.RegisterCheckInMessageRequest request){
            throw unimplementedMethodException(registerCheckInMessageMethod);
        }





        @Override
        public final ServiceDescriptor getServiceDescriptor() {
            return serviceDescriptor;
        }
        private RpcException unimplementedMethodException(StubMethodDescriptor methodDescriptor) {
            return TriRpcStatus.UNIMPLEMENTED.withDescription(String.format("Method %s is unimplemented",
                "/" + serviceDescriptor.getInterfaceName() + "/" + methodDescriptor.getMethodName())).asException();
        }
    }

}
