package ir.batomobil.web_service;


import ir.batomobil.dto.*;
import ir.batomobil.dto.request.*;
import ir.batomobil.dto.request.base.*;
import retrofit2.Call;

/**
 * In th name of God
 * 
 * Created by code genrator on Mon, 26 Jan 2026 19:00:23.
 * Dont change this file.
 */

 public class ApiIntermediate { 


    public static APIInterface getApiInterface(int version) {
        return APIClient.getClient(version).create(APIInterface.class);
    }

    public static APIInterface getExtendedTimeoutInterface(int version) {
        return APIClient.getExtendedTimeoutClient(version, true).create(APIInterface.class);
    }
    

  public static Call<ResAdsMenuDto> adsMenu(ReqCarUidDto reqDto) {
        Call<ResAdsMenuDto> c = getApiInterface(1).adsMenu(reqDto);
        return new CacheCall<ResAdsMenuDto>(reqDto, c, ResAdsMenuDto.class);
    }
                  

  public static Call<ResBillRequestPayDto> billRequestPay(ReqBillRequestPayDto reqDto) {
        Call<ResBillRequestPayDto> c = getApiInterface(1).billRequestPay(reqDto);
        return new CacheCall<ResBillRequestPayDto>(reqDto, c, ResBillRequestPayDto.class);
    }
                  

  public static Call<ResBillTracksDto> billTracks(ReqDto reqDto) {
        Call<ResBillTracksDto> c = getApiInterface(1).billTracks(reqDto);
        return new CacheCall<ResBillTracksDto>(reqDto, c, ResBillTracksDto.class);
    }
                  

  public static Call<ResCarMycarsDto> carMycars(ReqDto reqDto) {
        Call<ResCarMycarsDto> c = getApiInterface(1).carMycars(reqDto);
        return new CacheCall<ResCarMycarsDto>(reqDto, c, ResCarMycarsDto.class);
    }
                  

  public static Call<ResCarDeleteDto> carDelete(ReqUidDto reqDto) {
        Call<ResCarDeleteDto> c = getApiInterface(1).carDelete(reqDto);
        return new CacheCall<ResCarDeleteDto>(reqDto, c, ResCarDeleteDto.class);
    }
                  

  public static Call<ResCarMenuDto> carMenu(ReqUidDto reqDto) {
        Call<ResCarMenuDto> c = getApiInterface(1).carMenu(reqDto);
        return new CacheCall<ResCarMenuDto>(reqDto, c, ResCarMenuDto.class);
    }
                  

  public static Call<ResCarInfoDto> carEdit(ReqCarEditDto reqDto) {
        Call<ResCarInfoDto> c = getApiInterface(1).carEdit(reqDto);
        return new CacheCall<ResCarInfoDto>(reqDto, c, ResCarInfoDto.class);
    }
                  

  public static Call<ResCarTollDto> carToll(ReqUidDto reqDto) {
        Call<ResCarTollDto> c = getApiInterface(1).carToll(reqDto);
        return new CacheCall<ResCarTollDto>(reqDto, c, ResCarTollDto.class);
    }
                  

  public static Call<ResCarTehranDebtDto> carTehranDebt(ReqUidDto reqDto) {
        Call<ResCarTehranDebtDto> c = getApiInterface(1).carTehranDebt(reqDto);
        return new CacheCall<ResCarTehranDebtDto>(reqDto, c, ResCarTehranDebtDto.class);
    }
                  

  public static Call<ResCarTehranDebtPayLinkDto> carTehranDebtPayLink(ReqCarTehranDebtPayLinkDto reqDto) {
        Call<ResCarTehranDebtPayLinkDto> c = getApiInterface(1).carTehranDebtPayLink(reqDto);
        return new CacheCall<ResCarTehranDebtPayLinkDto>(reqDto, c, ResCarTehranDebtPayLinkDto.class);
    }
                  

  public static Call<ResCarTechInfoDto> carTechInfo(ReqUidDto reqDto) {
        Call<ResCarTechInfoDto> c = getApiInterface(1).carTechInfo(reqDto);
        return new CacheCall<ResCarTechInfoDto>(reqDto, c, ResCarTechInfoDto.class);
    }
                  

  public static Call<ResCarAccidentDto> carAccident(ReqCarAccidentDto reqDto) {
        Call<ResCarAccidentDto> c = getApiInterface(1).carAccident(reqDto);
        return new CacheCall<ResCarAccidentDto>(reqDto, c, ResCarAccidentDto.class);
    }
                  

  public static Call<ResCarFolderDto> carFolder(ReqUidDto reqDto) {
        Call<ResCarFolderDto> c = getApiInterface(1).carFolder(reqDto);
        return new CacheCall<ResCarFolderDto>(reqDto, c, ResCarFolderDto.class);
    }
                  

  public static Call<ResCarcompanyActivesDto> carcompanyActives(ReqDto reqDto) {
        Call<ResCarcompanyActivesDto> c = getApiInterface(1).carcompanyActives(reqDto);
        return new CacheCall<ResCarcompanyActivesDto>(reqDto, c, ResCarcompanyActivesDto.class);
    }
                  

  public static Call<ResCarcompanySubActivesDto> carcompanySubActives(ReqUidDto reqDto) {
        Call<ResCarcompanySubActivesDto> c = getApiInterface(1).carcompanySubActives(reqDto);
        return new CacheCall<ResCarcompanySubActivesDto>(reqDto, c, ResCarcompanySubActivesDto.class);
    }
                  

  public static Call<ResCarpriceListDto> carpriceList(ReqDto reqDto) {
        Call<ResCarpriceListDto> c = getApiInterface(1).carpriceList(reqDto);
        return new CacheCall<ResCarpriceListDto>(reqDto, c, ResCarpriceListDto.class);
    }
                  

  public static Call<ResCarpriceChartDto> carpriceChart(ReqCarpriceChartDto reqDto) {
        Call<ResCarpriceChartDto> c = getApiInterface(1).carpriceChart(reqDto);
        return new CacheCall<ResCarpriceChartDto>(reqDto, c, ResCarpriceChartDto.class);
    }
                  

  public static Call<ResCertificateWarningCaptchaDto> certificateWarningCaptcha(ReqDto reqDto) {
        Call<ResCertificateWarningCaptchaDto> c = getApiInterface(1).certificateWarningCaptcha(reqDto);
        return new CacheCall<ResCertificateWarningCaptchaDto>(reqDto, c, ResCertificateWarningCaptchaDto.class);
    }
                  

  public static Call<ResCertificateWarningRequestDto> certificateWarningRequest(ReqCertificateWarningRequestDto reqDto) {
        Call<ResCertificateWarningRequestDto> c = getApiInterface(1).certificateWarningRequest(reqDto);
        return new CacheCall<ResCertificateWarningRequestDto>(reqDto, c, ResCertificateWarningRequestDto.class);
    }
                  

  public static Call<ResCertificateWarningTableDto> certificateWarningTable(ReqDto reqDto) {
        Call<ResCertificateWarningTableDto> c = getApiInterface(1).certificateWarningTable(reqDto);
        return new CacheCall<ResCertificateWarningTableDto>(reqDto, c, ResCertificateWarningTableDto.class);
    }
                  

  public static Call<ResContentItemDto> contentItem(ReqContentItemDto reqDto) {
        Call<ResContentItemDto> c = getApiInterface(1).contentItem(reqDto);
        return new CacheCall<ResContentItemDto>(reqDto, c, ResContentItemDto.class);
    }
                  

  public static Call<ResDiscountMylistDto> discountMylist(ReqDto reqDto) {
        Call<ResDiscountMylistDto> c = getApiInterface(1).discountMylist(reqDto);
        return new CacheCall<ResDiscountMylistDto>(reqDto, c, ResDiscountMylistDto.class);
    }
                  

  public static Call<ResDiscountActivateDto> discountActivate(ReqDiscountActivateDto reqDto) {
        Call<ResDiscountActivateDto> c = getApiInterface(1).discountActivate(reqDto);
        return new CacheCall<ResDiscountActivateDto>(reqDto, c, ResDiscountActivateDto.class);
    }
                  

  public static Call<ResEnumCartypeDto> enumCartype(ReqDto reqDto) {
        Call<ResEnumCartypeDto> c = getApiInterface(1).enumCartype(reqDto);
        return new CacheCall<ResEnumCartypeDto>(reqDto, c, ResEnumCartypeDto.class);
    }
                  

  public static Call<ResEnumCartypeSubDto> enumCartypeSub(ReqEnumCartypeSubDto reqDto) {
        Call<ResEnumCartypeSubDto> c = getApiInterface(1).enumCartypeSub(reqDto);
        return new CacheCall<ResEnumCartypeSubDto>(reqDto, c, ResEnumCartypeSubDto.class);
    }
                  

  public static Call<ResEnumUidTitleDto> enumUidTitle(ReqDto reqDto) {
        Call<ResEnumUidTitleDto> c = getApiInterface(1).enumUidTitle(reqDto);
        return new CacheCall<ResEnumUidTitleDto>(reqDto, c, ResEnumUidTitleDto.class);
    }
                  

  public static Call<ResExtraListDto> extraList(ReqDto reqDto) {
        Call<ResExtraListDto> c = getApiInterface(1).extraList(reqDto);
        return new CacheCall<ResExtraListDto>(reqDto, c, ResExtraListDto.class);
    }
                  

  public static Call<ResExtraEmergencyTellDto> extraEmergencyTell(ReqDto reqDto) {
        Call<ResExtraEmergencyTellDto> c = getApiInterface(1).extraEmergencyTell(reqDto);
        return new CacheCall<ResExtraEmergencyTellDto>(reqDto, c, ResExtraEmergencyTellDto.class);
    }
                  

  public static Call<ResFactorMysellsDto> factorMysells(ReqFactorMysellsDto reqDto) {
        Call<ResFactorMysellsDto> c = getApiInterface(1).factorMysells(reqDto);
        return new CacheCall<ResFactorMysellsDto>(reqDto, c, ResFactorMysellsDto.class);
    }
                  

  public static Call<ResFactorMybuiesDto> factorMybuies(ReqFactorMybuiesDto reqDto) {
        Call<ResFactorMybuiesDto> c = getApiInterface(1).factorMybuies(reqDto);
        return new CacheCall<ResFactorMybuiesDto>(reqDto, c, ResFactorMybuiesDto.class);
    }
                  

  public static Call<ResFactorInfoDto> factorInfo(ReqUidDto reqDto) {
        Call<ResFactorInfoDto> c = getApiInterface(1).factorInfo(reqDto);
        return new CacheCall<ResFactorInfoDto>(reqDto, c, ResFactorInfoDto.class);
    }
                  

  public static Call<ResFactorAddDto> factorAdd(ReqFactorAddDto reqDto) {
        Call<ResFactorAddDto> c = getApiInterface(1).factorAdd(reqDto);
        return new CacheCall<ResFactorAddDto>(reqDto, c, ResFactorAddDto.class);
    }
                  

  public static Call<ResFactorOrderDto> factorOrder(ReqFactorOrderDto reqDto) {
        Call<ResFactorOrderDto> c = getApiInterface(1).factorOrder(reqDto);
        return new CacheCall<ResFactorOrderDto>(reqDto, c, ResFactorOrderDto.class);
    }
                  

  public static Call<ResFactorUpdateStateDto> factorUpdateState(ReqFactorUpdateStateDto reqDto) {
        Call<ResFactorUpdateStateDto> c = getApiInterface(1).factorUpdateState(reqDto);
        return new CacheCall<ResFactorUpdateStateDto>(reqDto, c, ResFactorUpdateStateDto.class);
    }
                  

  public static Call<ResFactorStateEnumDto> factorStateEnum(ReqUidDto reqDto) {
        Call<ResFactorStateEnumDto> c = getApiInterface(1).factorStateEnum(reqDto);
        return new CacheCall<ResFactorStateEnumDto>(reqDto, c, ResFactorStateEnumDto.class);
    }
                  

  public static Call<ResFcmTestDto> fcmTest(ReqDto reqDto) {
        Call<ResFcmTestDto> c = getApiInterface(1).fcmTest(reqDto);
        return new CacheCall<ResFcmTestDto>(reqDto, c, ResFcmTestDto.class);
    }
                  

  public static Call<ResFileUploadDto> fileUpload(ReqFileUploadDto reqDto) {
        Call<ResFileUploadDto> c = getApiInterface(1).fileUpload(reqDto);
        return new CacheCall<ResFileUploadDto>(reqDto, c, ResFileUploadDto.class);
    }
                  

  public static Call<ResFileUrlDto> fileUrl(ReqFileUrlDto reqDto) {
        Call<ResFileUrlDto> c = getApiInterface(1).fileUrl(reqDto);
        return new CacheCall<ResFileUrlDto>(reqDto, c, ResFileUrlDto.class);
    }
                  

  public static Call<ResFileDownloadDto> fileDownload(ReqFileDownloadDto reqDto) {
        Call<ResFileDownloadDto> c = getApiInterface(1).fileDownload(reqDto);
        return new CacheCall<ResFileDownloadDto>(reqDto, c, ResFileDownloadDto.class);
    }
                  

  public static Call<ResFileThumbnailDto> fileThumbnail(ReqFileThumbnailDto reqDto) {
        Call<ResFileThumbnailDto> c = getApiInterface(1).fileThumbnail(reqDto);
        return new CacheCall<ResFileThumbnailDto>(reqDto, c, ResFileThumbnailDto.class);
    }
                  

  public static Call<ResForfeitRequestDto> forfeitRequest(ReqCarUidDto reqDto) {
        Call<ResForfeitRequestDto> c = getApiInterface(1).forfeitRequest(reqDto);
        return new CacheCall<ResForfeitRequestDto>(reqDto, c, ResForfeitRequestDto.class);
    }
                  

  public static Call<ResForfeitTableDto> forfeitTable(ReqCarUidDto reqDto) {
        Call<ResForfeitTableDto> c = getApiInterface(1).forfeitTable(reqDto);
        return new CacheCall<ResForfeitTableDto>(reqDto, c, ResForfeitTableDto.class);
    }
                  

  public static Call<ResForfeitPanelChartDto> forfeitPanelChart(ReqCarUidDto reqDto) {
        Call<ResForfeitPanelChartDto> c = getApiInterface(1).forfeitPanelChart(reqDto);
        return new CacheCall<ResForfeitPanelChartDto>(reqDto, c, ResForfeitPanelChartDto.class);
    }
                  

  public static Call<ResGoodsGaListDto> goodsGaList(ReqGoodsGaListDto reqDto) {
        Call<ResGoodsGaListDto> c = getApiInterface(1).goodsGaList(reqDto);
        return new CacheCall<ResGoodsGaListDto>(reqDto, c, ResGoodsGaListDto.class);
    }
                  

  public static Call<ResGoodsGaInfoDto> goodsGaInfo(ReqUidDto reqDto) {
        Call<ResGoodsGaInfoDto> c = getApiInterface(1).goodsGaInfo(reqDto);
        return new CacheCall<ResGoodsGaInfoDto>(reqDto, c, ResGoodsGaInfoDto.class);
    }
                  

  public static Call<ResGoodsWpListDto> goodsWpList(ReqWorkplaceUidDto reqDto) {
        Call<ResGoodsWpListDto> c = getApiInterface(1).goodsWpList(reqDto);
        return new CacheCall<ResGoodsWpListDto>(reqDto, c, ResGoodsWpListDto.class);
    }
                  

  public static Call<ResGoodsWpInfoDto> goodsWpInfo(ReqGoodsWpInfoDto reqDto) {
        Call<ResGoodsWpInfoDto> c = getApiInterface(1).goodsWpInfo(reqDto);
        return new CacheCall<ResGoodsWpInfoDto>(reqDto, c, ResGoodsWpInfoDto.class);
    }
                  

  public static Call<ResGoodsWpEditDto> goodsWpEdit(ReqGoodsWpEditDto reqDto) {
        Call<ResGoodsWpEditDto> c = getApiInterface(1).goodsWpEdit(reqDto);
        return new CacheCall<ResGoodsWpEditDto>(reqDto, c, ResGoodsWpEditDto.class);
    }
                  

  public static Call<ResInsuranceReqPriceDto> insuranceReqPrice(ReqInsuranceReqPriceDto reqDto) {
        Call<ResInsuranceReqPriceDto> c = getApiInterface(1).insuranceReqPrice(reqDto);
        return new CacheCall<ResInsuranceReqPriceDto>(reqDto, c, ResInsuranceReqPriceDto.class);
    }
                  

  public static Call<ResInsuranceOrderDto> insuranceOrder(ReqInsuranceOrderDto reqDto) {
        Call<ResInsuranceOrderDto> c = getApiInterface(1).insuranceOrder(reqDto);
        return new CacheCall<ResInsuranceOrderDto>(reqDto, c, ResInsuranceOrderDto.class);
    }
                  

  public static Call<ResUidTitleListDto> insuranceEnumCover(ReqDto reqDto) {
        Call<ResUidTitleListDto> c = getApiInterface(1).insuranceEnumCover(reqDto);
        return new CacheCall<ResUidTitleListDto>(reqDto, c, ResUidTitleListDto.class);
    }
                  

  public static Call<ResUidTitleListDto> insuranceEnumOldDuration(ReqDto reqDto) {
        Call<ResUidTitleListDto> c = getApiInterface(1).insuranceEnumOldDuration(reqDto);
        return new CacheCall<ResUidTitleListDto>(reqDto, c, ResUidTitleListDto.class);
    }
                  

  public static Call<ResUidTitleListDto> insuranceEnumCarTypes(ReqDto reqDto) {
        Call<ResUidTitleListDto> c = getApiInterface(1).insuranceEnumCarTypes(reqDto);
        return new CacheCall<ResUidTitleListDto>(reqDto, c, ResUidTitleListDto.class);
    }
                  

  public static Call<ResUidTitleListDto> insuranceEnumCompanies(ReqDto reqDto) {
        Call<ResUidTitleListDto> c = getApiInterface(1).insuranceEnumCompanies(reqDto);
        return new CacheCall<ResUidTitleListDto>(reqDto, c, ResUidTitleListDto.class);
    }
                  

  public static Call<ResUidTitleListDto> insuranceEnumExemptDriver(ReqDto reqDto) {
        Call<ResUidTitleListDto> c = getApiInterface(1).insuranceEnumExemptDriver(reqDto);
        return new CacheCall<ResUidTitleListDto>(reqDto, c, ResUidTitleListDto.class);
    }
                  

  public static Call<ResUidTitleListDto> insuranceEnumExemptThirdParty(ReqDto reqDto) {
        Call<ResUidTitleListDto> c = getApiInterface(1).insuranceEnumExemptThirdParty(reqDto);
        return new CacheCall<ResUidTitleListDto>(reqDto, c, ResUidTitleListDto.class);
    }
                  

  public static Call<ResUidTitleListDto> insuranceEnumDamages(ReqDto reqDto) {
        Call<ResUidTitleListDto> c = getApiInterface(1).insuranceEnumDamages(reqDto);
        return new CacheCall<ResUidTitleListDto>(reqDto, c, ResUidTitleListDto.class);
    }
                  

  public static Call<ResKhalafiEstelamDto> khalafiEstelam(ReqDto reqDto) {
        Call<ResKhalafiEstelamDto> c = getApiInterface(1).khalafiEstelam(reqDto);
        return new CacheCall<ResKhalafiEstelamDto>(reqDto, c, ResKhalafiEstelamDto.class);
    }
                  

  public static Call<ResMessageMylistDto> messageMylist(ReqDto reqDto) {
        Call<ResMessageMylistDto> c = getApiInterface(1).messageMylist(reqDto);
        return new CacheCall<ResMessageMylistDto>(reqDto, c, ResMessageMylistDto.class);
    }
                  

  public static Call<ResPayItemDto> payItem(ReqUidDto reqDto) {
        Call<ResPayItemDto> c = getApiInterface(1).payItem(reqDto);
        return new CacheCall<ResPayItemDto>(reqDto, c, ResPayItemDto.class);
    }
                  

  public static Call<ResPayTracksDto> payTracks(ReqDto reqDto) {
        Call<ResPayTracksDto> c = getApiInterface(1).payTracks(reqDto);
        return new CacheCall<ResPayTracksDto>(reqDto, c, ResPayTracksDto.class);
    }
                  

  public static Call<ResPresentationCarListDto> presentationCarList(ReqDto reqDto) {
        Call<ResPresentationCarListDto> c = getApiInterface(1).presentationCarList(reqDto);
        return new CacheCall<ResPresentationCarListDto>(reqDto, c, ResPresentationCarListDto.class);
    }
                  

  public static Call<ResPresentationInfoDto> presentationInfo(ReqPresentationInfoDto reqDto) {
        Call<ResPresentationInfoDto> c = getApiInterface(1).presentationInfo(reqDto);
        return new CacheCall<ResPresentationInfoDto>(reqDto, c, ResPresentationInfoDto.class);
    }
                  

  public static Call<ResPresentationTechInfoDto> presentationTechInfo(ReqUidDto reqDto) {
        Call<ResPresentationTechInfoDto> c = getApiInterface(1).presentationTechInfo(reqDto);
        return new CacheCall<ResPresentationTechInfoDto>(reqDto, c, ResPresentationTechInfoDto.class);
    }
                  

  public static Call<ResPresentationCommentsDto> presentationComments(ReqUidDto reqDto) {
        Call<ResPresentationCommentsDto> c = getApiInterface(1).presentationComments(reqDto);
        return new CacheCall<ResPresentationCommentsDto>(reqDto, c, ResPresentationCommentsDto.class);
    }
                  

  public static Call<ResPresentationPricesDto> presentationPrices(ReqUidDto reqDto) {
        Call<ResPresentationPricesDto> c = getApiInterface(1).presentationPrices(reqDto);
        return new CacheCall<ResPresentationPricesDto>(reqDto, c, ResPresentationPricesDto.class);
    }
                  

  public static Call<ResPresentationAddCommentDto> presentationAddComment(ReqPresentationAddCommentDto reqDto) {
        Call<ResPresentationAddCommentDto> c = getApiInterface(1).presentationAddComment(reqDto);
        return new CacheCall<ResPresentationAddCommentDto>(reqDto, c, ResPresentationAddCommentDto.class);
    }
                  

  public static Call<ResPricePlanListDto> pricePlanList(ReqDto reqDto) {
        Call<ResPricePlanListDto> c = getApiInterface(1).pricePlanList(reqDto);
        return new CacheCall<ResPricePlanListDto>(reqDto, c, ResPricePlanListDto.class);
    }
                  

  public static Call<ResPricePlanActivateDto> pricePlanActivate(ReqPricePlanActivateDto reqDto) {
        Call<ResPricePlanActivateDto> c = getApiInterface(1).pricePlanActivate(reqDto);
        return new CacheCall<ResPricePlanActivateDto>(reqDto, c, ResPricePlanActivateDto.class);
    }
                  

  public static Call<ResReferralCoworkDto> referralCowork(ReqUidDto reqDto) {
        Call<ResReferralCoworkDto> c = getApiInterface(1).referralCowork(reqDto);
        return new CacheCall<ResReferralCoworkDto>(reqDto, c, ResReferralCoworkDto.class);
    }
                  

  public static Call<ResRegisterFcmDto> registerFcm(ReqRegisterFcmDto reqDto) {
        Call<ResRegisterFcmDto> c = getApiInterface(1).registerFcm(reqDto);
        return new CacheCall<ResRegisterFcmDto>(reqDto, c, ResRegisterFcmDto.class);
    }
                  

  public static Call<ResRegisterUserDto> registerUser(ReqRegisterUserDto reqDto) {
        Call<ResRegisterUserDto> c = getApiInterface(1).registerUser(reqDto);
        return new CacheCall<ResRegisterUserDto>(reqDto, c, ResRegisterUserDto.class);
    }
                  

  public static Call<ResRegisterMobileDto> registerMobile(ReqRegisterMobileDto reqDto) {
        Call<ResRegisterMobileDto> c = getApiInterface(1).registerMobile(reqDto);
        return new CacheCall<ResRegisterMobileDto>(reqDto, c, ResRegisterMobileDto.class);
    }
                  

  public static Call<ResReminderMylistDto> reminderMylist(ReqCarUidDto reqDto) {
        Call<ResReminderMylistDto> c = getApiInterface(1).reminderMylist(reqDto);
        return new CacheCall<ResReminderMylistDto>(reqDto, c, ResReminderMylistDto.class);
    }
                  

  public static Call<ResReminderInfoDto> reminderInfo(ReqUidDto reqDto) {
        Call<ResReminderInfoDto> c = getApiInterface(1).reminderInfo(reqDto);
        return new CacheCall<ResReminderInfoDto>(reqDto, c, ResReminderInfoDto.class);
    }
                  

  public static Call<ResReminderInfoDto> reminderAdd(ReqReminderAddDto reqDto) {
        Call<ResReminderInfoDto> c = getApiInterface(1).reminderAdd(reqDto);
        return new CacheCall<ResReminderInfoDto>(reqDto, c, ResReminderInfoDto.class);
    }
                  

  public static Call<ResReminderInfoDto> reminderEdit(ReqReminderEditDto reqDto) {
        Call<ResReminderInfoDto> c = getApiInterface(1).reminderEdit(reqDto);
        return new CacheCall<ResReminderInfoDto>(reqDto, c, ResReminderInfoDto.class);
    }
                  

  public static Call<ResReminderInfoDto> reminderDelete(ReqUidDto reqDto) {
        Call<ResReminderInfoDto> c = getApiInterface(1).reminderDelete(reqDto);
        return new CacheCall<ResReminderInfoDto>(reqDto, c, ResReminderInfoDto.class);
    }
                  

  public static Call<ResReminderEnumTypesDto> reminderEnumTypes(ReqDto reqDto) {
        Call<ResReminderEnumTypesDto> c = getApiInterface(1).reminderEnumTypes(reqDto);
        return new CacheCall<ResReminderEnumTypesDto>(reqDto, c, ResReminderEnumTypesDto.class);
    }
                  

  public static Call<ResSupportAddDto> supportAdd(ReqSupportAddDto reqDto) {
        Call<ResSupportAddDto> c = getApiInterface(1).supportAdd(reqDto);
        return new CacheCall<ResSupportAddDto>(reqDto, c, ResSupportAddDto.class);
    }
                  

  public static Call<ResSupportListDto> supportList(ReqDto reqDto) {
        Call<ResSupportListDto> c = getApiInterface(1).supportList(reqDto);
        return new CacheCall<ResSupportListDto>(reqDto, c, ResSupportListDto.class);
    }
                  

  public static Call<ResTechQuestionListDto> techQuestionList(ReqCarUidDto reqDto) {
        Call<ResTechQuestionListDto> c = getApiInterface(1).techQuestionList(reqDto);
        return new CacheCall<ResTechQuestionListDto>(reqDto, c, ResTechQuestionListDto.class);
    }
                  

  public static Call<ResTechQuestionAddDto> techQuestionAdd(ReqTechQuestionAddDto reqDto) {
        Call<ResTechQuestionAddDto> c = getApiInterface(1).techQuestionAdd(reqDto);
        return new CacheCall<ResTechQuestionAddDto>(reqDto, c, ResTechQuestionAddDto.class);
    }
                  

  public static Call<ResTechQuestionSetRateDto> techQuestionSetRate(ReqTechQuestionSetRateDto reqDto) {
        Call<ResTechQuestionSetRateDto> c = getApiInterface(1).techQuestionSetRate(reqDto);
        return new CacheCall<ResTechQuestionSetRateDto>(reqDto, c, ResTechQuestionSetRateDto.class);
    }
                  

  public static Call<ResUserInstallDto> userInstall(ReqUserInstallDto reqDto) {
        Call<ResUserInstallDto> c = getApiInterface(1).userInstall(reqDto);
        return new CacheCall<ResUserInstallDto>(reqDto, c, ResUserInstallDto.class);
    }
                  

  public static Call<ResUserInfoDto> userInfo(ReqDto reqDto) {
        Call<ResUserInfoDto> c = getApiInterface(1).userInfo(reqDto);
        return new CacheCall<ResUserInfoDto>(reqDto, c, ResUserInfoDto.class);
    }
                  

  public static Call<ResUserRegFcmDto> userRegFcm(ReqUserRegFcmDto reqDto) {
        Call<ResUserRegFcmDto> c = getApiInterface(1).userRegFcm(reqDto);
        return new CacheCall<ResUserRegFcmDto>(reqDto, c, ResUserRegFcmDto.class);
    }
                  

  public static Call<ResUserMobileReqVerifyDto> userMobileReqVerify(ReqUserMobileReqVerifyDto reqDto) {
        Call<ResUserMobileReqVerifyDto> c = getApiInterface(1).userMobileReqVerify(reqDto);
        return new CacheCall<ResUserMobileReqVerifyDto>(reqDto, c, ResUserMobileReqVerifyDto.class);
    }
                  

  public static Call<ResUserMobileVerifyCodeDto> userMobileVerifyCode(ReqUserMobileVerifyCodeDto reqDto) {
        Call<ResUserMobileVerifyCodeDto> c = getApiInterface(1).userMobileVerifyCode(reqDto);
        return new CacheCall<ResUserMobileVerifyCodeDto>(reqDto, c, ResUserMobileVerifyCodeDto.class);
    }
                  

  public static Call<ResUserLogoutDto> userLogout(ReqDto reqDto) {
        Call<ResUserLogoutDto> c = getApiInterface(1).userLogout(reqDto);
        return new CacheCall<ResUserLogoutDto>(reqDto, c, ResUserLogoutDto.class);
    }
                  

  public static Call<ResWorkplaceMyworkplacesDto> workplaceMyworkplaces(ReqDto reqDto) {
        Call<ResWorkplaceMyworkplacesDto> c = getApiInterface(1).workplaceMyworkplaces(reqDto);
        return new CacheCall<ResWorkplaceMyworkplacesDto>(reqDto, c, ResWorkplaceMyworkplacesDto.class);
    }
                  

  public static Call<ResWorkplaceMenuDto> workplaceMenu(ReqUidDto reqDto) {
        Call<ResWorkplaceMenuDto> c = getApiInterface(1).workplaceMenu(reqDto);
        return new CacheCall<ResWorkplaceMenuDto>(reqDto, c, ResWorkplaceMenuDto.class);
    }
                  

  public static Call<ResWorkplaceInfoDto> workplaceInfo(ReqUidDto reqDto) {
        Call<ResWorkplaceInfoDto> c = getApiInterface(1).workplaceInfo(reqDto);
        return new CacheCall<ResWorkplaceInfoDto>(reqDto, c, ResWorkplaceInfoDto.class);
    }
                  

  public static Call<ResWorkplaceEditDto> workplaceEdit(ReqWorkplaceEditDto reqDto) {
        Call<ResWorkplaceEditDto> c = getApiInterface(1).workplaceEdit(reqDto);
        return new CacheCall<ResWorkplaceEditDto>(reqDto, c, ResWorkplaceEditDto.class);
    }
                  

  public static Call<ResWorkplaceMycoworkDto> workplaceMycowork(ReqWorkplaceUidDto reqDto) {
        Call<ResWorkplaceMycoworkDto> c = getApiInterface(1).workplaceMycowork(reqDto);
        return new CacheCall<ResWorkplaceMycoworkDto>(reqDto, c, ResWorkplaceMycoworkDto.class);
    }
                  

  public static Call<ResWorkplaceCoworkInfoDto> workplaceCoworkInfo(ReqUidDto reqDto) {
        Call<ResWorkplaceCoworkInfoDto> c = getApiInterface(1).workplaceCoworkInfo(reqDto);
        return new CacheCall<ResWorkplaceCoworkInfoDto>(reqDto, c, ResWorkplaceCoworkInfoDto.class);
    }
                  

  public static Call<ResCarMycarsDto> carAdd(ReqCarAddDto reqDto) {
        Call<ResCarMycarsDto> c = getApiInterface(2).carAdd(reqDto);
        return new CacheCall<ResCarMycarsDto>(reqDto, c, ResCarMycarsDto.class);
    }
                  



}