@hapl/api-queries 0.1.193 → 0.2.0

package/src/clients/v1/index.ts

@@ -1,794 +1,810 @@
 import * as api from './api';
 
 export class Api {
-  constructor(private baseURL: string | undefined) {}
+  constructor(private baseURL: Promise<string | undefined> | string | undefined) {}
 
   // auth
 
-  getPassword = (params: api.GetPasswordParams) => {
-    return api.getPasswordRequest({ params, baseURL: this.baseURL });
+  getPassword = async (params: api.GetPasswordParams) => {
+    return api.getPasswordRequest({ params, baseURL: await this.baseURL });
   };
 
-  checkPassword = (body: api.CheckPasswordBody) => {
-    return api.checkPasswordRequest({ body, baseURL: this.baseURL });
+  checkPassword = async (body: api.CheckPasswordBody) => {
+    return api.checkPasswordRequest({ body, baseURL: await this.baseURL });
   };
 
-  checkToken = (headers: api.CheckTokenHeaders) => {
-    return api.checkTokenRequest({ headers, baseURL: this.baseURL });
+  checkToken = async (headers: api.CheckTokenHeaders) => {
+    return api.checkTokenRequest({ headers, baseURL: await this.baseURL });
   };
 
   // available funds
 
-  createAvailableFunds = (body: api.CreateAvailableFundsBody, headers: api.CreateAvailableFundsHeaders) => {
-    return api.createAvailableFundsRequest({ body, headers, baseURL: this.baseURL });
+  createAvailableFunds = async (body: api.CreateAvailableFundsBody, headers: api.CreateAvailableFundsHeaders) => {
+    return api.createAvailableFundsRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  findAvailableFunds = (params: api.FindAvailableFundsParams, headers: api.FindAvailableFundsHeaders) => {
-    return api.findAvailableFundsRequest({ params, headers, baseURL: this.baseURL });
+  findAvailableFunds = async (params: api.FindAvailableFundsParams, headers: api.FindAvailableFundsHeaders) => {
+    return api.findAvailableFundsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  updateAvailableFunds = (
+  updateAvailableFunds = async (
     urlParams: api.UpdateAvailableFundsUrlParams,
     body: api.UpdateAvailableFundsBody,
     headers: api.UpdateAvailableFundsHeaders
   ) => {
-    return api.updateAvailableFundsRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updateAvailableFundsRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  deleteAvailableFunds = (urlParams: api.DeleteAvailableFundsUrlParams, headers: api.DeleteAvailableFundsHeaders) => {
-    return api.deleteAvailableFundsRequest({ urlParams, headers, baseURL: this.baseURL });
+  deleteAvailableFunds = async (
+    urlParams: api.DeleteAvailableFundsUrlParams,
+    headers: api.DeleteAvailableFundsHeaders
+  ) => {
+    return api.deleteAvailableFundsRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
   // bill
 
-  createBill = (body: api.CreateBillBody, headers: api.CreateBillHeaders) => {
-    return api.createBillRequest({ body, headers, baseURL: this.baseURL });
+  createBill = async (body: api.CreateBillBody, headers: api.CreateBillHeaders) => {
+    return api.createBillRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  findBills = (params: api.FindBillsParams, headers: api.FindBillsHeaders) => {
-    return api.findBillsRequest({ params, headers, baseURL: this.baseURL });
+  findBills = async (params: api.FindBillsParams, headers: api.FindBillsHeaders) => {
+    return api.findBillsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
   // buyer
 
-  callbackBuyer = (urlParams: api.CallbackBuyerUrlParams, headers: api.CallbackBuyerHeaders) => {
-    return api.callbackBuyerRequest({ urlParams, headers, baseURL: this.baseURL });
+  callbackBuyer = async (urlParams: api.CallbackBuyerUrlParams, headers: api.CallbackBuyerHeaders) => {
+    return api.callbackBuyerRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  countBuyers = (params: api.CountBuyersParams, headers: api.CountBuyersHeaders) => {
-    return api.countBuyersRequest({ params, headers, baseURL: this.baseURL });
+  countBuyers = async (params: api.CountBuyersParams, headers: api.CountBuyersHeaders) => {
+    return api.countBuyersRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  createBuyer = (body: api.CreateBuyerBody, headers: api.CallbackBuyerHeaders) => {
-    return api.createBuyerRequest({ body, headers, baseURL: this.baseURL });
+  createBuyer = async (body: api.CreateBuyerBody, headers: api.CallbackBuyerHeaders) => {
+    return api.createBuyerRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  findBuyerClosingReason = (headers: api.FindBuyerClosingReasonHeaders) => {
-    return api.findBuyerClosingReasonRequest({ headers, baseURL: this.baseURL });
+  findBuyerClosingReason = async (headers: api.FindBuyerClosingReasonHeaders) => {
+    return api.findBuyerClosingReasonRequest({ headers, baseURL: await this.baseURL });
   };
 
-  findBuyers = (params: api.FindBuyersParams, headers: api.FindBuyersHeaders) => {
-    return api.findBuyersRequest({ params, headers, baseURL: this.baseURL });
+  findBuyers = async (params: api.FindBuyersParams, headers: api.FindBuyersHeaders) => {
+    return api.findBuyersRequest({ params, headers, baseURL: await this.baseURL });
   };
 
   // call
 
-  findCalls = (params: api.FindCallsParams, headers: api.FindCallsHeaders) => {
-    return api.findCallsRequest({ params, headers, baseURL: this.baseURL });
+  findCalls = async (params: api.FindCallsParams, headers: api.FindCallsHeaders) => {
+    return api.findCallsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  findFirstSuccessOutgoingCalls = (
+  findFirstSuccessOutgoingCalls = async (
     params: api.FindFirstSuccessOutgoingCallsParams,
     headers: api.FindFirstSuccessOutgoingCallsHeaders
   ) => {
-    return api.findFirstSuccessOutgoingCallsRequest({ params, headers, baseURL: this.baseURL });
+    return api.findFirstSuccessOutgoingCallsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  markupCall = (body: api.MarkupCallBody, headers: api.MarkupCallHeaders) => {
-    return api.markupCallRequest({ body, headers, baseURL: this.baseURL });
+  markupCall = async (body: api.MarkupCallBody, headers: api.MarkupCallHeaders) => {
+    return api.markupCallRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  removeProxyPhone = (headers: api.RemoveProxyPhoneHeaders) => {
-    return api.removeProxyPhoneRequest({ headers, baseURL: this.baseURL });
+  removeProxyPhone = async (headers: api.RemoveProxyPhoneHeaders) => {
+    return api.removeProxyPhoneRequest({ headers, baseURL: await this.baseURL });
   };
 
-  setProxyPhone = (body: api.SetProxyPhoneBody, headers: api.SetProxyPhoneHeaders) => {
-    return api.setProxyPhoneRequest({ body, headers, baseURL: this.baseURL });
+  setProxyPhone = async (body: api.SetProxyPhoneBody, headers: api.SetProxyPhoneHeaders) => {
+    return api.setProxyPhoneRequest({ body, headers, baseURL: await this.baseURL });
   };
 
   // call center
 
-  finishOperatorWork = (headers: api.FinishOperatorWorkHeaders) => {
-    return api.finishOperatorWorkRequest({ headers, baseURL: this.baseURL });
+  finishOperatorWork = async (headers: api.FinishOperatorWorkHeaders) => {
+    return api.finishOperatorWorkRequest({ headers, baseURL: await this.baseURL });
   };
 
-  startOperatorWork = (headers: api.StartOperatorWorkHeaders) => {
-    return api.startOperatorWorkRequest({ headers, baseURL: this.baseURL });
+  startOperatorWork = async (headers: api.StartOperatorWorkHeaders) => {
+    return api.startOperatorWorkRequest({ headers, baseURL: await this.baseURL });
   };
 
-  getOperatorStatus = (headers: api.GetOperatorStatusHeaders) => {
-    return api.getOperatorStatusRequest({ headers, baseURL: this.baseURL });
+  getOperatorStatus = async (headers: api.GetOperatorStatusHeaders) => {
+    return api.getOperatorStatusRequest({ headers, baseURL: await this.baseURL });
   };
 
   // call task
 
-  createCallTask = (body: api.CreateCallTaskBody, headers?: api.CreateCallTaskHeaders) => {
-    return api.createCallTaskRequest({ body, headers, baseURL: this.baseURL });
+  createCallTask = async (body: api.CreateCallTaskBody, headers?: api.CreateCallTaskHeaders) => {
+    return api.createCallTaskRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  findCallTasks = (params: api.FindCallTasksParams, headers: api.FindCallTasksHeaders) => {
-    return api.findCallTasksRequest({ params, headers, baseURL: this.baseURL });
+  findCallTasks = async (params: api.FindCallTasksParams, headers: api.FindCallTasksHeaders) => {
+    return api.findCallTasksRequest({ params, headers, baseURL: await this.baseURL });
   };
 
   // contract
 
-  approveContract = (
+  approveContract = async (
     urlParams: api.ApproveContractUrlParams,
     body: api.ApproveContractBody,
     headers: api.ApproveContractHeaders
   ) => {
-    return api.approveContractRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.approveContractRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  createContract = (body: api.CreateContractBody, headers: api.CreateContractHeaders) => {
-    return api.createContractRequest({ body, headers, baseURL: this.baseURL });
+  createContract = async (body: api.CreateContractBody, headers: api.CreateContractHeaders) => {
+    return api.createContractRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  createContractLegalDocument = (
+  createContractLegalDocument = async (
     urlParams: api.CreateContractLegalDocumentUrlParams,
     headers: api.CreateContractLegalDocumentHeaders
   ) => {
-    return api.createContractLegalDocumentRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.createContractLegalDocumentRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  declineContract = (
+  declineContract = async (
     urlParams: api.DeclineContractUrlParams,
     body: api.DeclineContractBody,
     headers: api.DeclineContractHeaders
   ) => {
-    return api.declineContractRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.declineContractRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  findContracts = (params: api.FindContractsParams, headers: api.FindContractsHeaders) => {
-    return api.findContractsRequest({ params, headers, baseURL: this.baseURL });
+  findContracts = async (params: api.FindContractsParams, headers: api.FindContractsHeaders) => {
+    return api.findContractsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  findContractById = (urlParams: api.FindContractByIdUrlParams, headers: api.FindContractByIdHeaders) => {
-    return api.findContractByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+  findContractById = async (urlParams: api.FindContractByIdUrlParams, headers: api.FindContractByIdHeaders) => {
+    return api.findContractByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findContractDocumentByContractId = (
+  findContractDocumentByContractId = async (
     urlParams: api.FindContractDocumentByContractIdUrlParams,
     headers: api.FindContractDocumentByContractIdHeaders
   ) => {
-    return api.findContractDocumentByContractIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.findContractDocumentByContractIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findContractLegalDocumentByContractId = (
+  findContractLegalDocumentByContractId = async (
     urlParams: api.FindContractLegalDocumentByContractIdUrlParams,
     headers: api.FindContractLegalDocumentByContractIdHeaders
   ) => {
-    return api.findContractLegalDocumentByContractIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.findContractLegalDocumentByContractIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  signContract = (
+  signContract = async (
     urlParams: api.SignContractUrlParams,
     body: api.SignContractBody,
     headers: api.SignContractHeaders
   ) => {
-    return api.signContractRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.signContractRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  terminateContract = (
+  terminateContract = async (
     urlParams: api.TerminateContractUrlParams,
     body: api.TerminateContractBody,
     headers: api.TerminateContractHeaders
   ) => {
-    return api.terminateContractRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.terminateContractRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  updateContract = (
+  updateContract = async (
     urlParams: api.UpdateContractUrlParams,
     body: api.UpdateContractBody,
     headers: api.UpdateContractHeaders
   ) => {
-    return api.updateContractRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updateContractRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  updateContractDocument = (
+  updateContractDocument = async (
     urlParams: api.UpdateContractDocumentUrlParams,
     body: api.UpdateContractDocumentBody,
     headers: api.UpdateContractDocumentHeaders
   ) => {
-    return api.updateContractDocumentRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updateContractDocumentRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  upgradeContract = (
+  upgradeContract = async (
     urlParams: api.UpgradeContractUrlParams,
     body: api.UpgradeContractBody,
     headers: api.UpgradeContractHeaders
   ) => {
-    return api.upgradeContractRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.upgradeContractRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
   // crossSale
 
-  deleteCrossSale = (urlParams: api.DeleteCrossSaleUrlParams, headers: api.DeleteCrossSaleHeaders) => {
-    return api.deleteCrossSaleRequest({ urlParams, headers, baseURL: this.baseURL });
+  deleteCrossSale = async (urlParams: api.DeleteCrossSaleUrlParams, headers: api.DeleteCrossSaleHeaders) => {
+    return api.deleteCrossSaleRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findCrossSale = (urlParams: api.FindCrossSaleUrlParams, headers: api.FindCrossSaleHeaders) => {
-    return api.findCrossSaleRequest({ urlParams, headers, baseURL: this.baseURL });
+  findCrossSale = async (urlParams: api.FindCrossSaleUrlParams, headers: api.FindCrossSaleHeaders) => {
+    return api.findCrossSaleRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  updateCrossSale = (
+  updateCrossSale = async (
     urlParams: api.UpdateCrossSaleUrlParams,
     body: api.UpdateCrossSaleBody,
     headers: api.UpdateCrossSaleHeaders
   ) => {
-    return api.updateCrossSaleRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updateCrossSaleRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
   // deal
 
-  createDealCategorizedFile = (
+  createDealCategorizedFile = async (
     urlParams: api.CreateDealCategorizedFileUrlParams,
     body: api.CreateDealCategorizedFileBody,
     headers: api.CreateDealCategorizedFileHeaders
   ) => {
-    return api.createDealCategorizedFileRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.createDealCategorizedFileRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  createDealInvestPrepayment = (
+  createDealInvestPrepayment = async (
     urlParams: api.CreateDealInvestPrepaymentUrlParams,
     body: api.CreateDealInvestPrepaymentBody,
     headers: api.CreateDealInvestPrepaymentHeaders
   ) => {
-    return api.createDealInvestPrepaymentRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.createDealInvestPrepaymentRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  findDealCategorizedFiles = (
+  findDealCategorizedFiles = async (
     urlParams: api.FindDealCategorizedFilesUrlParams,
     params: api.FindDealCategorizedFilesParams,
     headers: api.FindDealCategorizedFilesHeaders
   ) => {
-    return api.findDealCategorizedFilesRequest({ urlParams, params, headers, baseURL: this.baseURL });
+    return api.findDealCategorizedFilesRequest({ urlParams, params, headers, baseURL: await this.baseURL });
   };
 
-  findDeals = (params: api.FindDealsParams, headers: api.FindDealsHeaders) => {
-    return api.findDealsRequest({ params, headers, baseURL: this.baseURL });
+  findDeals = async (params: api.FindDealsParams, headers: api.FindDealsHeaders) => {
+    return api.findDealsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  deleteDealCategorizedFile = (
+  deleteDealCategorizedFile = async (
     urlParams: api.DeleteDealCategorizedFileUrlParams,
     headers: api.DeleteDealCategorizedFileHeaders
   ) => {
-    return api.deleteDealCategorizedFileRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.deleteDealCategorizedFileRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  setDealDoneState = (urlParams: api.SetDealDoneStateUrlParams, headers: api.SetDealDoneStateHeaders) => {
-    return api.setDealDoneStateRequest({ urlParams, headers, baseURL: this.baseURL });
+  setDealDoneState = async (urlParams: api.SetDealDoneStateUrlParams, headers: api.SetDealDoneStateHeaders) => {
+    return api.setDealDoneStateRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  setDealPrepaymentState = (
+  setDealPrepaymentState = async (
     urlParams: api.SetDealPrepaymentStateUrlParams,
     body: api.SetDealPrepaymentStateBody,
     headers: api.SetDealPrepaymentStateHeaders
   ) => {
-    return api.setDealPrepaymentStateRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.setDealPrepaymentStateRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  setDealRegisteredState = (
+  setDealRegisteredState = async (
     urlParams: api.SetDealRegisteredStateUrlParams,
     body: api.SetDealRegisteredStateBody,
     headers: api.SetDealRegisteredStateHeaders
   ) => {
-    return api.setDealRegisteredStateRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.setDealRegisteredStateRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  setDealSignedState = (
+  setDealSignedState = async (
     urlParams: api.SetDealSignedStateUrlParams,
     body: api.SetDealSignedStateBody,
     headers: api.SetDealSignedStateHeaders
   ) => {
-    return api.setDealSignedStateRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.setDealSignedStateRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  setDealSignPlannedState = (
+  setDealSignPlannedState = async (
     urlParams: api.SetDealSignPlannedStateUrlParams,
     body: api.SetDealSignPlannedStateBody,
     headers: api.SetDealSignPlannedStateHeaders
   ) => {
-    return api.setDealSignPlannedStateRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.setDealSignPlannedStateRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  terminateDeal = (
+  terminateDeal = async (
     urlParams: api.TerminateDealUrlParams,
     body: api.TerminateDealBody,
     headers: api.TerminateDealHeaders
   ) => {
-    return api.terminateDealRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.terminateDealRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  updateDeal = (urlParams: api.UpdateDealUrlParams, body: api.UpdateDealBody, headers: api.UpdateDealHeaders) => {
-    return api.updateDealRequest({ urlParams, body, headers, baseURL: this.baseURL });
+  updateDeal = async (urlParams: api.UpdateDealUrlParams, body: api.UpdateDealBody, headers: api.UpdateDealHeaders) => {
+    return api.updateDealRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
   // event
 
-  createEvent = (body: api.CreateEventBody, headers: api.CreateEventHeaders) => {
-    return api.createEventRequest({ body, headers, baseURL: this.baseURL });
+  createEvent = async (body: api.CreateEventBody, headers: api.CreateEventHeaders) => {
+    return api.createEventRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  deleteEvent = (urlParams: api.DeleteEventUrlParams, headers: api.DeleteEventHeaders) => {
-    return api.deleteEventRequest({ urlParams, headers, baseURL: this.baseURL });
+  deleteEvent = async (urlParams: api.DeleteEventUrlParams, headers: api.DeleteEventHeaders) => {
+    return api.deleteEventRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findEventById = (urlParams: api.FindEventByIdUrlParams, headers?: api.FindEventByIdHeaders) => {
-    return api.findEventByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+  findEventById = async (urlParams: api.FindEventByIdUrlParams, headers?: api.FindEventByIdHeaders) => {
+    return api.findEventByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findEvents = (params: api.FindEventsParams, headers?: api.FindEventsHeaders) => {
-    return api.findEventsRequest({ params, headers, baseURL: this.baseURL });
+  findEvents = async (params: api.FindEventsParams, headers?: api.FindEventsHeaders) => {
+    return api.findEventsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  updateEvent = (urlParams: api.UpdateEventUrlParams, body: api.UpdateEventBody, headers: api.UpdateEventHeaders) => {
-    return api.updateEventRequest({ urlParams, body, headers, baseURL: this.baseURL });
+  updateEvent = async (
+    urlParams: api.UpdateEventUrlParams,
+    body: api.UpdateEventBody,
+    headers: api.UpdateEventHeaders
+  ) => {
+    return api.updateEventRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
   // expert
 
-  createExpertCase = (body: api.CreateExpertCaseBody, headers?: api.CreateExpertCaseHeaders) => {
-    return api.createExpertCaseRequest({ body, headers, baseURL: this.baseURL });
+  createExpertCase = async (body: api.CreateExpertCaseBody, headers?: api.CreateExpertCaseHeaders) => {
+    return api.createExpertCaseRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  createExpertReview = (
+  createExpertReview = async (
     urlParams: api.CreateExpertReviewUrlParams,
     body: api.CreateExpertReviewBody,
     headers: api.CreateExpertReviewHeaders
   ) => {
-    return api.createExpertReviewRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.createExpertReviewRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  findExpertById = (urlParams: api.FindExpertByIdUrlParams, headers: api.FindExpertByIdHeaders) => {
-    return api.findExpertByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+  findExpertById = async (urlParams: api.FindExpertByIdUrlParams, headers: api.FindExpertByIdHeaders) => {
+    return api.findExpertByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findExpertCaseById = (urlParams: api.FindExpertCaseByIdUrlParams, headers?: api.FindExpertCaseByIdHeaders) => {
-    return api.findExpertCaseByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+  findExpertCaseById = async (urlParams: api.FindExpertCaseByIdUrlParams, headers?: api.FindExpertCaseByIdHeaders) => {
+    return api.findExpertCaseByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findExpertCases = (headers?: api.FindExpertCasesHeaders) => {
-    return api.findExpertCasesRequest({ headers, baseURL: this.baseURL });
+  findExpertCases = async (headers?: api.FindExpertCasesHeaders) => {
+    return api.findExpertCasesRequest({ headers, baseURL: await this.baseURL });
   };
 
-  findExperts = (params: api.FindExpertsParams) => {
-    return api.findExpertsRequest({ params, baseURL: this.baseURL });
+  findExperts = async (params: api.FindExpertsParams) => {
+    return api.findExpertsRequest({ params, baseURL: await this.baseURL });
   };
 
-  findPublishedExperts = (params: api.FindPublishedExpertsParams) => {
-    return api.findPublishedExpertsRequest({ params, baseURL: this.baseURL });
+  findPublishedExperts = async (params: api.FindPublishedExpertsParams) => {
+    return api.findPublishedExpertsRequest({ params, baseURL: await this.baseURL });
   };
 
-  updateExpertCase = (
+  updateExpertCase = async (
     urlParams: api.UpdateExpertCaseUrlParams,
     body: api.UpdateExpertCaseBody,
     headers: api.UpdateExpertCaseHeaders
   ) => {
-    return api.updateExpertCaseRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updateExpertCaseRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  updateExpertReview = (
+  updateExpertReview = async (
     urlParams: api.UpdateExpertReviewUrlParams,
     body: api.UpdateExpertReviewBody,
     headers: api.UpdateExpertReviewHeaders
   ) => {
-    return api.updateExpertReviewRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updateExpertReviewRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
   // file
 
-  uploadFiles = (body: api.UploadFilesBody, headers: api.UploadFilesHeaders) => {
-    return api.uploadFilesRequest({ body, headers, baseURL: this.baseURL });
+  uploadFiles = async (body: api.UploadFilesBody, headers: api.UploadFilesHeaders) => {
+    return api.uploadFilesRequest({ body, headers, baseURL: await this.baseURL });
   };
 
   // income
 
-  createIncome = (body: api.CreateIncomeBody, headers: api.CreateIncomeHeaders) => {
-    return api.createIncomeRequest({ body, headers, baseURL: this.baseURL });
+  createIncome = async (body: api.CreateIncomeBody, headers: api.CreateIncomeHeaders) => {
+    return api.createIncomeRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  deleteIncome = (urlParams: api.DeleteIncomeUrlParams, headers: api.CreateIncomeHeaders) => {
-    return api.deleteIncomeRequest({ urlParams, headers, baseURL: this.baseURL });
+  deleteIncome = async (urlParams: api.DeleteIncomeUrlParams, headers: api.CreateIncomeHeaders) => {
+    return api.deleteIncomeRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
   // phoneBookContact
 
-  createPhoneBookContact = (body: api.CreatePhoneBookContactBody, headers: api.CreatePhoneBookContactHeaders) => {
-    return api.createPhoneBookContactRequest({ body, headers, baseURL: this.baseURL });
+  createPhoneBookContact = async (body: api.CreatePhoneBookContactBody, headers: api.CreatePhoneBookContactHeaders) => {
+    return api.createPhoneBookContactRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  findPhoneBookContacts = (params: api.FindPhoneBookContactsParams, headers: api.FindPhoneBookContactsHeaders) => {
-    return api.findPhoneBookContactsRequest({ params, headers, baseURL: this.baseURL });
+  findPhoneBookContacts = async (
+    params: api.FindPhoneBookContactsParams,
+    headers: api.FindPhoneBookContactsHeaders
+  ) => {
+    return api.findPhoneBookContactsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  updatePhoneBookContact = (
+  updatePhoneBookContact = async (
     urlParams: api.UpdatePhoneBookContactUrlParams,
     body: api.UpdatePhoneBookContactBody,
     headers: api.UpdatePhoneBookContactHeaders
   ) => {
-    return api.updatePhoneBookContactRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updatePhoneBookContactRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  deletePhoneBookContact = (
+  deletePhoneBookContact = async (
     urlParams: api.DeletePhoneBookContactUrlParams,
     headers: api.DeletePhoneBookContactHeaders
   ) => {
-    return api.deletePhoneBookContactRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.deletePhoneBookContactRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
   // photoOrder
 
-  createPhotoOrder = (body: api.CreatePhotoOrderBody, headers: api.CreatePhotoOrderHeaders) => {
-    return api.createPhotoOrderRequest({ body, headers, baseURL: this.baseURL });
+  createPhotoOrder = async (body: api.CreatePhotoOrderBody, headers: api.CreatePhotoOrderHeaders) => {
+    return api.createPhotoOrderRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  findPhotoOrders = (params: api.FindPhotoOrdersParams, headers: api.FindPhotoOrdersHeaders) => {
-    return api.findPhotoOrdersRequest({ params, headers, baseURL: this.baseURL });
+  findPhotoOrders = async (params: api.FindPhotoOrdersParams, headers: api.FindPhotoOrdersHeaders) => {
+    return api.findPhotoOrdersRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  sendPhotoOrderFeedback = (
+  sendPhotoOrderFeedback = async (
     urlParams: api.SendPhotoOrderFeedbackUrlParams,
     headers: api.SendPhotoOrderFeedbackHeaders
   ) => {
-    return api.sendPhotoOrderFeedbackRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.sendPhotoOrderFeedbackRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  terminatePhotoOrder = (urlParams: api.TerminatePhotoOrderUrlParams, headers: api.TerminatePhotoOrderHeaders) => {
-    return api.terminatePhotoOrderRequest({ urlParams, headers, baseURL: this.baseURL });
+  terminatePhotoOrder = async (
+    urlParams: api.TerminatePhotoOrderUrlParams,
+    headers: api.TerminatePhotoOrderHeaders
+  ) => {
+    return api.terminatePhotoOrderRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
   // serviceRequest
 
-  approveCloseServiceRequest = (
+  approveCloseServiceRequest = async (
     urlParams: api.ApproveCloseServiceRequestUrlParams,
     body: api.ApproveCloseServiceRequestBody,
     headers: api.ApproveCloseServiceRequestHeaders
   ) => {
-    return api.approveCloseServiceRequestRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.approveCloseServiceRequestRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  callbackServiceRequest = (
+  callbackServiceRequest = async (
     urlParams: api.CallbackServiceRequestUrlParams,
     headers: api.CallbackServiceRequestHeaders
   ) => {
-    return api.callbackServiceRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.callbackServiceRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  closeServiceRequest = (
+  closeServiceRequest = async (
     urlParams: api.CloseServiceRequestUrlParams,
     body: api.CloseServiceRequestBody,
     headers: api.CloseServiceRequestHeaders
   ) => {
-    return api.closeServiceRequestRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.closeServiceRequestRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  completeServiceRequestModeration = (
+  completeServiceRequestModeration = async (
     urlParams: api.CompleteServiceRequestModerationUrlParams,
     headers: api.CompleteServiceRequestModerationHeaders
   ) => {
-    return api.completeServiceRequestModerationRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.completeServiceRequestModerationRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  createServiceRequest = (body: api.CreateServiceRequestBody, headers: api.CreateServiceRequestHeaders) => {
-    return api.createServiceRequestRequest({ body, headers, baseURL: this.baseURL });
+  createServiceRequest = async (body: api.CreateServiceRequestBody, headers: api.CreateServiceRequestHeaders) => {
+    return api.createServiceRequestRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  createInvestSellServiceRequest = (
+  createInvestSellServiceRequest = async (
     body: api.CreateInvestSellServiceRequestBody,
     headers: api.CreateInvestSellServiceRequestHeaders
   ) => {
-    return api.createInvestSellServiceRequestRequest({ body, headers, baseURL: this.baseURL });
+    return api.createInvestSellServiceRequestRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  createServiceRequestByCrossSaleId = (
+  createServiceRequestByCrossSaleId = async (
     urlParams: api.CreateServiceRequestByCrossSaleIdUrlParams,
     headers: api.CreateServiceRequestByCrossSaleIdHeaders
   ) => {
-    return api.createServiceRequestByCrossSaleIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.createServiceRequestByCrossSaleIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  createServiceRequestActivity = (
+  createServiceRequestActivity = async (
     body: api.CreateServiceRequestActivityBody,
     headers: api.CreateServiceRequestActivityHeaders
   ) => {
-    return api.createServiceRequestActivityRequest({ body, headers, baseURL: this.baseURL });
+    return api.createServiceRequestActivityRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  createServiceRequestCategorizedFile = (
+  createServiceRequestCategorizedFile = async (
     urlParams: api.CreateServiceRequestCategorizedFileUrlParams,
     body: api.CreateServiceRequestCategorizedFileBody,
     headers: api.CreateServiceRequestCategorizedFileHeaders
   ) => {
-    return api.createServiceRequestCategorizedFileRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.createServiceRequestCategorizedFileRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  deferServiceRequest = (body: api.DeferServiceRequestBody, headers: api.DeferServiceRequestHeaders) => {
-    return api.deferServiceRequestRequest({ body, headers, baseURL: this.baseURL });
+  deferServiceRequest = async (body: api.DeferServiceRequestBody, headers: api.DeferServiceRequestHeaders) => {
+    return api.deferServiceRequestRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  deleteServiceRequestCategorizedFile = (
+  deleteServiceRequestCategorizedFile = async (
     urlParams: api.DeleteServiceRequestCategorizedFileUrlParams,
     headers: api.DeleteServiceRequestCategorizedFileHeaders
   ) => {
-    return api.deleteServiceRequestCategorizedFileRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.deleteServiceRequestCategorizedFileRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  deleteServiceRequestReportForSeller = (
+  deleteServiceRequestReportForSeller = async (
     urlParams: api.DeleteServiceRequestReportForSellerUrlParams,
     headers: api.DeleteServiceRequestReportForSellerHeaders
   ) => {
-    return api.deleteServiceRequestReportForSellerRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.deleteServiceRequestReportForSellerRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  depublishServiceRequest = (
+  depublishServiceRequest = async (
     urlParams: api.DepublishServiceRequestUrlParams,
     headers: api.DepublishServiceRequestHeaders,
     body: api.DepublishServiceRequestBody
   ) => {
-    return api.depublishServiceRequest({ urlParams, headers, body, baseURL: this.baseURL });
+    return api.depublishServiceRequest({ urlParams, headers, body, baseURL: await this.baseURL });
   };
 
-  disapproveCloseServiceRequest = (
+  disapproveCloseServiceRequest = async (
     urlParams: api.DisapproveCloseServiceRequestUrlParams,
     headers: api.DisapproveCloseServiceRequestHeaders
   ) => {
-    return api.disapproveCloseServiceRequestRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.disapproveCloseServiceRequestRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestActivities = (
+  findServiceRequestActivities = async (
     params: api.FindServiceRequestActivitiesParams,
     headers: api.FindServiceRequestActivitiesHeaders
   ) => {
-    return api.findServiceRequestActivitiesRequest({ params, headers, baseURL: this.baseURL });
+    return api.findServiceRequestActivitiesRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestById = (
+  findServiceRequestById = async (
     urlParams: api.FindServiceRequestByIdUrlParams,
     headers: api.FindServiceRequestByIdHeaders
   ) => {
-    return api.findServiceRequestByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.findServiceRequestByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestDuplicates = (
+  findServiceRequestDuplicates = async (
     body: api.FindServiceRequestDuplicatesBody,
     headers: api.FindServiceRequestDuplicatesHeaders
   ) => {
-    return api.findServiceRequestDuplicatesRequest({ body, headers, baseURL: this.baseURL });
+    return api.findServiceRequestDuplicatesRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequests = (params: api.FindServiceRequestsParams, headers: api.FindServiceRequestsHeaders) => {
-    return api.findServiceRequestsRequest({ params, headers, baseURL: this.baseURL });
+  findServiceRequests = async (params: api.FindServiceRequestsParams, headers: api.FindServiceRequestsHeaders) => {
+    return api.findServiceRequestsRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestShortInfo = (
+  findServiceRequestShortInfo = async (
     params: api.FindServiceRequestsShortInfoParams,
     headers: api.FindServiceRequestShortInfoHeaders
   ) => {
-    return api.findServiceRequestShortInfoRequest({ params, headers, baseURL: this.baseURL });
+    return api.findServiceRequestShortInfoRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestShortInfoByDealId = (
+  findServiceRequestShortInfoByDealId = async (
     urlParams: api.FindServiceRequestShortInfoByDealIdUrlParams,
     headers: api.FindServiceRequestShortInfoByDealIdHeaders
   ) => {
-    return api.findServiceRequestShortInfoByDealIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.findServiceRequestShortInfoByDealIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestShortInfoById = (
+  findServiceRequestShortInfoById = async (
     urlParams: api.FindServiceRequestShortInfoByIdUrlParams,
     headers: api.FindServiceRequestShortInfoByIdHeaders
   ) => {
-    return api.findServiceRequestShortInfoByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.findServiceRequestShortInfoByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestStatisticsById = (
+  findServiceRequestStatisticsById = async (
     urlParams: api.FindServiceRequestStatisticsByIdUrlParams,
     headers: api.FindServiceRequestStatisticsByIdHeaders
   ) => {
-    return api.findServiceRequestStatisticsByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.findServiceRequestStatisticsByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestCategorizedFiles = (
+  findServiceRequestCategorizedFiles = async (
     urlParams: api.FindServiceRequestCategorizedFilesUrlParams,
     params: api.FindServiceRequestCategorizedFilesParams,
     headers: api.FindServiceRequestCategorizedFilesHeaders
   ) => {
-    return api.findServiceRequestCategorizedFilesRequest({ urlParams, params, headers, baseURL: this.baseURL });
+    return api.findServiceRequestCategorizedFilesRequest({ urlParams, params, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestCategorizedFileCreatedDate = (
+  findServiceRequestCategorizedFileCreatedDate = async (
     urlParams: api.FindServiceRequestCategorizedFileCreatedDateUrlParams,
     headers: api.FindServiceRequestCategorizedFileCreatedDateHeaders
   ) => {
     return api.findServiceRequestCategorizedFileCreatedDateRequest({
       urlParams,
       headers,
-      baseURL: this.baseURL,
+      baseURL: await this.baseURL,
     });
   };
 
-  findPriceHistoryAnalyticsById = (
+  findPriceHistoryAnalyticsById = async (
     urlParams: api.FindPriceHistoryAnalyticsByIdUrlParams,
     headers: api.FindPriceHistoryAnalyticsByIdHeaders
   ) => {
-    return api.findPriceHistoryAnalyticsByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.findPriceHistoryAnalyticsByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findServiceRequestSellerReports = (
+  findServiceRequestSellerReports = async (
     urlParams: api.FindServiceRequestSellerReportsUrlParams,
     params: api.FindServiceRequestSellerReportsParams,
     headers: api.FindServiceRequestSellerReportsHeaders
   ) => {
-    return api.findServiceRequestSellerReportsRequest({ urlParams, params, headers, baseURL: this.baseURL });
+    return api.findServiceRequestSellerReportsRequest({ urlParams, params, headers, baseURL: await this.baseURL });
   };
 
-  publishServiceRequest = (
+  publishServiceRequest = async (
     urlParams: api.PublishServiceRequestUrlParams,
     headers: api.PublishServiceRequestHeaders
   ) => {
-    return api.publishServiceRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.publishServiceRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  returnDeferredServiceRequest = (
+  returnDeferredServiceRequest = async (
     body: api.ReturnDeferredServiceRequestBody,
     headers: api.ReturnDeferredServiceRequestHeaders
   ) => {
-    return api.returnDeferredServiceRequestRequest({ body, headers, baseURL: this.baseURL });
+    return api.returnDeferredServiceRequestRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  sendServiceRequestToModeration = (
+  sendServiceRequestToModeration = async (
     urlParams: api.SendServiceRequestToModerationUrlParams,
     headers: api.SendServiceRequestToModerationHeaders
   ) => {
-    return api.sendServiceRequestToModerationRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.sendServiceRequestToModerationRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  startServiceRequestModeration = (
+  startServiceRequestModeration = async (
     urlParams: api.StartServiceRequestModerationUrlParams,
     headers: api.StartServiceRequestModerationHeaders
   ) => {
-    return api.startServiceRequestModerationRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.startServiceRequestModerationRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  startServiceRequestModerationForOldRealty = (
+  startServiceRequestModerationForOldRealty = async (
     urlParams: api.StartServiceRequestModerationForOldRealtyUrlParams,
     headers: api.StartServiceRequestModerationForOldRealtyHeaders
   ) => {
-    return api.startServiceRequestModerationForOldRealtyRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.startServiceRequestModerationForOldRealtyRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  transferServiceRequest = (
+  transferServiceRequest = async (
     urlParams: api.TransferServiceRequestUrlParams,
     body: api.TransferServiceRequestBody,
     headers: api.TransferServiceRequestHeaders
   ) => {
-    return api.transferServiceRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.transferServiceRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  updateServiceRequest = (
+  updateServiceRequest = async (
     urlParams: api.UpdateServiceRequestUrlParams,
     body: api.UpdateServiceRequestBody,
     headers: api.UpdateServiceRequestHeaders
   ) => {
-    return api.updateServiceRequestRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updateServiceRequestRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
   // sold
 
-  findSoldStatistic = (headers?: api.FindSoldStatisticHeaders) => {
-    return api.findSoldStatisticRequest({ headers, baseURL: this.baseURL });
+  findSoldStatistic = async (headers?: api.FindSoldStatisticHeaders) => {
+    return api.findSoldStatisticRequest({ headers, baseURL: await this.baseURL });
   };
 
   // task
 
-  findTasks = (params: api.FindTasksParams, headers: api.FindTasksHeaders) => {
-    return api.findTasksRequest({ params, headers, baseURL: this.baseURL });
+  findTasks = async (params: api.FindTasksParams, headers: api.FindTasksHeaders) => {
+    return api.findTasksRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  findTaskById = (urlParams: api.FindTaskByIdUrlParams, headers: api.FindTaskByIdHeaders) => {
-    return api.findTaskByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+  findTaskById = async (urlParams: api.FindTaskByIdUrlParams, headers: api.FindTaskByIdHeaders) => {
+    return api.findTaskByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  createTask = (body: api.CreateTaskBody, headers: api.CreateTaskHeaders) => {
-    return api.createTaskRequest({ body, headers, baseURL: this.baseURL });
+  createTask = async (body: api.CreateTaskBody, headers: api.CreateTaskHeaders) => {
+    return api.createTaskRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  updateTask = (urlParams: api.UpdateTaskUrlParams, body: api.UpdateTaskBody, headers: api.UpdateTaskHeaders) => {
-    return api.updateTaskRequest({ urlParams, body, headers, baseURL: this.baseURL });
+  updateTask = async (urlParams: api.UpdateTaskUrlParams, body: api.UpdateTaskBody, headers: api.UpdateTaskHeaders) => {
+    return api.updateTaskRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  resolveTask = (urlParams: api.ResolveTaskUrlParams, headers: api.UpdateTaskHeaders) => {
-    return api.resolveTaskRequest({ urlParams, headers, baseURL: this.baseURL });
+  resolveTask = async (urlParams: api.ResolveTaskUrlParams, headers: api.UpdateTaskHeaders) => {
+    return api.resolveTaskRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
   // user
 
-  assignSubordinateUsers = (
+  assignSubordinateUsers = async (
     urlParams: api.AssignSubordinateUsersUrlParams,
     body: api.AssignSubordinateUsersBody,
     headers: api.AssignSubordinateUsersHeaders
   ) => {
-    return api.assignSubordinateUsersRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.assignSubordinateUsersRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  createUser = (body: api.CreateUserBody, headers: api.CreateUserHeaders) => {
-    return api.createUserRequest({ body, headers, baseURL: this.baseURL });
+  createUser = async (body: api.CreateUserBody, headers: api.CreateUserHeaders) => {
+    return api.createUserRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  findUserById = (urlParams: api.FindUserByIdUrlParams, headers?: api.FindUserByIdHeaders) => {
-    return api.findUserByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+  findUserById = async (urlParams: api.FindUserByIdUrlParams, headers?: api.FindUserByIdHeaders) => {
+    return api.findUserByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findUserPasswordById = (urlParams: api.FindUserPasswordByIdUrlParams, headers?: api.FindUserPasswordByIdHeaders) => {
-    return api.findUserPasswordByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+  findUserPasswordById = async (
+    urlParams: api.FindUserPasswordByIdUrlParams,
+    headers?: api.FindUserPasswordByIdHeaders
+  ) => {
+    return api.findUserPasswordByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  findUsers = (params: api.FindUsersParams, headers: api.FindUsersHeaders) => {
-    return api.findUsersRequest({ params, headers, baseURL: this.baseURL });
+  findUsers = async (params: api.FindUsersParams, headers: api.FindUsersHeaders) => {
+    return api.findUsersRequest({ params, headers, baseURL: await this.baseURL });
   };
 
-  findUserTokenById = (urlParams: api.FindUserTokenByIdUrlParams, headers?: api.FindUserTokenByIdHeaders) => {
-    return api.findUserTokenByIdRequest({ urlParams, headers, baseURL: this.baseURL });
+  findUserTokenById = async (urlParams: api.FindUserTokenByIdUrlParams, headers?: api.FindUserTokenByIdHeaders) => {
+    return api.findUserTokenByIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  fireUser = (urlParams: api.FireUserUrlParams, body: api.FireUserBody, headers: api.FireUserHeaders) => {
-    return api.fireUserRequest({ urlParams, body, headers, baseURL: this.baseURL });
+  fireUser = async (urlParams: api.FireUserUrlParams, body: api.FireUserBody, headers: api.FireUserHeaders) => {
+    return api.fireUserRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  updateUser = (urlParams: api.UpdateUserUrlParams, body: api.UpdateUserBody, headers: api.UpdateUserHeaders) => {
-    return api.updateUserRequest({ urlParams, body, headers, baseURL: this.baseURL });
+  updateUser = async (urlParams: api.UpdateUserUrlParams, body: api.UpdateUserBody, headers: api.UpdateUserHeaders) => {
+    return api.updateUserRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
   // valuation
 
-  actualizeValuation = (urlParams: api.ActualizeValuationUrlParams, headers: api.ActualizeValuationHeaders) => {
-    return api.actualizeValuationRequest({ urlParams, headers, baseURL: this.baseURL });
+  actualizeValuation = async (urlParams: api.ActualizeValuationUrlParams, headers: api.ActualizeValuationHeaders) => {
+    return api.actualizeValuationRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  createValuation = (body: api.CreateValuationBody, headers: api.CreateValuationHeaders) => {
-    return api.createValuationRequest({ body, headers, baseURL: this.baseURL });
+  createValuation = async (body: api.CreateValuationBody, headers: api.CreateValuationHeaders) => {
+    return api.createValuationRequest({ body, headers, baseURL: await this.baseURL });
   };
 
-  createValuationRealtyComment = (
+  createValuationRealtyComment = async (
     urlParams: api.CreateValuationRealtyCommentUrlParams,
     body: api.CreateValuationRealtyCommentBody,
     headers: api.CreateValuationRealtyCommentHeaders
   ) => {
-    return api.createValuationRealtyCommentRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.createValuationRealtyCommentRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 
-  findValuationByServiceRequestId = (
+  findValuationByServiceRequestId = async (
     urlParams: api.FindValuationByServiceRequestIdUrlParams,
     params?: api.FindValuationByServiceRequestIdParams,
     headers?: api.FindValuationByServiceRequestIdHeaders
   ) => {
-    return api.findValuationByServiceRequestIdRequest({ urlParams, params, headers, baseURL: this.baseURL });
+    return api.findValuationByServiceRequestIdRequest({ urlParams, params, headers, baseURL: await this.baseURL });
   };
 
-  findValuationNewsByServiceRequestId = (
+  findValuationNewsByServiceRequestId = async (
     urlParams: api.FindValuationNewsByServiceRequestIdUrlParams,
     headers: api.FindValuationNewsByServiceRequestIdHeaders
   ) => {
-    return api.findValuationNewsByServiceRequestIdRequest({ urlParams, headers, baseURL: this.baseURL });
+    return api.findValuationNewsByServiceRequestIdRequest({ urlParams, headers, baseURL: await this.baseURL });
   };
 
-  updateValuationNewsStatus = (
+  updateValuationNewsStatus = async (
     urlParams: api.UpdateValuationNewsStatusUrlParams,
     body: api.UpdateValuationNewsStatusBody,
     headers: api.UpdateValuationNewsStatusHeaders
   ) => {
-    return api.updateValuationNewsStatusRequest({ urlParams, body, headers, baseURL: this.baseURL });
+    return api.updateValuationNewsStatusRequest({ urlParams, body, headers, baseURL: await this.baseURL });
   };
 }