hl-core 0.0.9-beta.1 → 0.0.9-beta.11

package/api/index.ts

@@ -1,5 +1,5 @@
 import { MemberCodes } from '../types/enum';
-import { useAxios } from '../composables/axios';
+import { useAxiosInstance } from '../composables/axios';
 import { Value, IDocument } from '../composables/classes';
 import { AxiosRequestConfig } from 'axios';
 
@@ -13,20 +13,20 @@ export class ApiClass {
   private readonly productUrl: string = import.meta.env.VITE_PRODUCT_URL as string;
 
   private async axiosCall<T>(config: AxiosRequestConfig): Promise<T> {
-    const { data } = await useAxios(this.baseURL).request<T>(config);
+    const { data } = await useAxiosInstance(this.baseURL).request<T>(config);
     return data;
   }
 
-  async loginUser(data: { login: string; password: string; numAttempt: number }): Promise<{ refreshToken: string; accessToken: string }> {
-    return this.axiosCall({
+  async loginUser(data: { login: string; password: string; numAttempt: number }) {
+    return await this.axiosCall<{ refreshToken: string; accessToken: string }>({
       method: Methods.POST,
       url: '/identity/api/Account/login',
       data: data,
     });
   }
 
-  async getNewAccessToken({ refreshToken, accessToken }: { refreshToken: string; accessToken: string }): Promise<{ refreshToken: string; accessToken: string }> {
-    return this.axiosCall({
+  async getNewAccessToken({ refreshToken, accessToken }: { refreshToken: string; accessToken: string }) {
+    return await this.axiosCall<{ refreshToken: string; accessToken: string }>({
       method: Methods.POST,
       url: '/identity/api/Account/refresh',
       headers: {
@@ -36,212 +36,212 @@ export class ApiClass {
     });
   }
 
-  async getCountries(): Promise<Value[]> {
-    return this.axiosCall({
+  async getCountries() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/Country',
     });
   }
 
-  async getCitizenshipCountries(): Promise<Value[]> {
-    return this.axiosCall({
+  async getCitizenshipCountries() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/Questionary?filter=500012',
     });
   }
 
-  async getTaxCountries(): Promise<Value[]> {
-    return this.axiosCall({
+  async getTaxCountries() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/Questionary?filter=500014',
     });
   }
 
-  async getAdditionalTaxCountries(): Promise<Value[]> {
-    return this.axiosCall({
+  async getAdditionalTaxCountries() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/Questionary?filter=507777',
     });
   }
 
-  async getStates(): Promise<Value[]> {
-    return this.axiosCall({
+  async getStates() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/State',
     });
   }
 
-  async getRegions(): Promise<Value[]> {
-    return this.axiosCall({
+  async getRegions() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/Region',
     });
   }
 
-  async getCities(): Promise<Value[]> {
-    return this.axiosCall({
+  async getCities() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/CityVillage',
     });
   }
 
-  async getLocalityTypes(): Promise<Value[]> {
-    return this.axiosCall({
+  async getLocalityTypes() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/LocalityType',
     });
   }
 
-  async getDocumentTypes(): Promise<Value[]> {
-    return this.axiosCall({
+  async getDocumentTypes() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/DocumentTypePhys',
     });
   }
 
-  async getDocumentIssuers(): Promise<Value[]> {
-    return this.axiosCall({
+  async getDocumentIssuers() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/DocIssuer',
     });
   }
 
-  async getResidents(): Promise<Value[]> {
-    return this.axiosCall({
+  async getResidents() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/Questionary?filter=500011',
     });
   }
 
-  async getSectorCode(): Promise<Value[]> {
-    return this.axiosCall({
+  async getSectorCode() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/Questionary?filter=500003',
     });
   }
 
-  async getFamilyStatuses(): Promise<Value[]> {
-    return this.axiosCall({
+  async getFamilyStatuses() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Arm/api/Dictionary/GetDictionaryItems/DicFamilyStatus',
     });
   }
 
-  async getRelationTypes(): Promise<Value[]> {
-    return this.axiosCall({
+  async getRelationTypes() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Ekk/api/Contragentinsis/DictionaryItems/Relation',
     });
   }
 
-  async getDicAnnuityTypeList(): Promise<Value[]> {
-    return this.axiosCall({
+  async getDicAnnuityTypeList() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Arm/api/Dictionary/GetDictionaryItems/DicAnnuityType',
     });
   }
 
-  async getCurrencies(): Promise<{ eur: number; usd: number }> {
-    return this.axiosCall({
+  async getCurrencies() {
+    return await this.axiosCall<{ eur: number; usd: number }>({
       method: Methods.GET,
       url: '/Ekk/api/Currency/GetExchange',
     });
   }
 
-  async getContragent(queryData: GetContragentRequest): Promise<GetContragentResponse> {
-    return this.axiosCall({
+  async getContragent(queryData: GetContragentRequest) {
+    return await this.axiosCall<GetContragentResponse>({
       method: Methods.GET,
       url: `/Ekk/api/Contragentinsis/Contragent?Iin=${queryData.iin}&FirstName=${queryData.firstName}&LastName=${queryData.lastName}&MiddleName=${queryData.middleName}`,
     });
   }
 
-  async getInsurancePay(): Promise<Value[]> {
-    return this.axiosCall({
+  async getInsurancePay() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Arm/api/Dictionary/GetDictionaryItems/DicBeneficiaryInsurancePay',
     });
   }
 
-  async getQuestionList(surveyType: string, processInstanceId: string | number, insuredId: number | string): Promise<AnketaFirst> {
-    return this.axiosCall({
+  async getQuestionList(surveyType: string, processInstanceId: string | number, insuredId: number | string) {
+    return await this.axiosCall<AnketaFirst>({
       method: Methods.GET,
       url: `/${this.productUrl}/api/Application/Anketa/${surveyType}/${processInstanceId}/${insuredId}`,
     });
   }
 
-  async getClientQuestionList(surveyType: string, processInstanceId: string | number, insuredId: number | string): Promise<AnketaFirst> {
-    return this.axiosCall({
+  async getClientQuestionList(surveyType: string, processInstanceId: string | number, insuredId: number | string) {
+    return await this.axiosCall<AnketaFirst>({
       method: Methods.GET,
       url: `/${this.productUrl}/api/Application/AnketaClient/${surveyType}/${processInstanceId}/${insuredId}`,
     });
   }
 
-  async getQuestionListSecond(surveyType: string, processInstanceId: string | number, insuredId: number | string): Promise<AnketaSecond[]> {
-    return this.axiosCall({
+  async getQuestionListSecond(surveyType: string, processInstanceId: string | number, insuredId: number | string) {
+    return await this.axiosCall<AnketaSecond[]>({
       method: Methods.GET,
       url: `/${this.productUrl}/api/Application/Anketa/${surveyType}/${processInstanceId}/${insuredId}`,
     });
   }
 
-  async getClientQuestionListSecond(surveyType: string, processInstanceId: string | number, insuredId: number | string): Promise<AnketaSecond[]> {
-    return this.axiosCall({
+  async getClientQuestionListSecond(surveyType: string, processInstanceId: string | number, insuredId: number | string) {
+    return await this.axiosCall<AnketaSecond[]>({
       method: Methods.GET,
       url: `/${this.productUrl}/api/Application/AnketaClient/${surveyType}/${processInstanceId}/${insuredId}`,
     });
   }
 
   async definedAnswers(filter: string) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.GET,
       url: `/Ekk/api/Contragentinsis/DictionaryItems/Questionary?filter=${filter}`,
     });
   }
 
-  async setSurvey(surveyData: AnketaFirst): Promise<string> {
-    return this.axiosCall({
+  async setSurvey(surveyData: AnketaFirst) {
+    return await this.axiosCall<string>({
       method: Methods.POST,
       data: surveyData,
       url: `/${this.productUrl}/api/Application/SetAnketa`,
     });
   }
 
-  async getQuestionRefs(id: string | number): Promise<Value[]> {
-    return this.axiosCall({
+  async getQuestionRefs(id: string | number) {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: `/Ekk/api/Contragentinsis/DictionaryItems/Questionary?filter=${id}`,
     });
   }
 
   async getProcessIndexRate(processCode: string | number) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.GET,
       url: `/Arm/api/Dictionary/ProcessIndexRate/${processCode}`,
     });
   }
 
-  async getAdditionalInsuranceTermsAnswers(processCode: string | number, questionId: string): Promise<AddCoverAnswer[]> {
-    return this.axiosCall({
+  async getAdditionalInsuranceTermsAnswers(processCode: string | number, questionId: string) {
+    return await this.axiosCall<AddCoverAnswer[]>({
       method: Methods.GET,
       url: `/Arm/api/Dictionary/ProcessCoverTypeSum/${processCode}/${questionId}`,
     });
   }
 
   async getProcessPaymentPeriod(processCode: string | number) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.GET,
       url: `/Arm/api/Dictionary/ProcessPaymentPeriod/${processCode}`,
     });
   }
 
   async getProcessAnnuityPaymentPeriod(processCode: string | number) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.GET,
       url: `/Arm/api/Dictionary/ProcessAnnuityPaymentPeriod/${processCode}`,
     });
   }
 
-  async getContragentById(id: number): Promise<GetContragentResponse> {
-    return this.axiosCall({
+  async getContragentById(id: number) {
+    return await this.axiosCall<GetContragentResponse>({
       method: Methods.GET,
       url: `/Ekk/api/Contragentinsis/Contragent?PersonId=${id}`,
     });
@@ -253,8 +253,8 @@ export class ApiClass {
     contacts: ContragentContacts[];
     documents: ContragentDocuments[];
     addresses: ContragentAddress[];
-  }): Promise<number> {
-    return this.axiosCall({
+  }) {
+    return await this.axiosCall<number>({
       method: Methods.POST,
       url: `/Ekk/api/Contragentinsis/SaveContragent`,
       data: data,
@@ -272,134 +272,134 @@ export class ApiClass {
     });
   }
 
-  async getDicFileTypeList(): Promise<Value[]> {
-    return this.axiosCall({
+  async getDicFileTypeList() {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: '/Arm/api/Dictionary/GetDictionaryItems/DicFileType',
     });
   }
 
-  async getContrAgentData(personId: string | number): Promise<ContragentQuestionaries[]> {
-    return this.axiosCall({
+  async getContrAgentData(personId: string | number) {
+    return await this.axiosCall<ContragentQuestionaries[]>({
       method: Methods.GET,
       url: `/Ekk/api/Contragentinsis/Questionaries?PersonId=${personId}`,
     });
   }
 
-  async getContrAgentContacts(personId: string | number): Promise<ContragentContacts[]> {
-    return this.axiosCall({
+  async getContrAgentContacts(personId: string | number) {
+    return await this.axiosCall<ContragentContacts[]>({
       method: Methods.GET,
       url: `/Ekk/api/Contragentinsis/Contacts?PersonId=${personId}`,
     });
   }
 
-  async getContrAgentDocuments(personId: string | number): Promise<ContragentDocuments[]> {
-    return this.axiosCall({
+  async getContrAgentDocuments(personId: string | number) {
+    return await this.axiosCall<ContragentDocuments[]>({
       method: Methods.GET,
       url: `/Ekk/api/Contragentinsis/Documents?PersonId=${personId}`,
     });
   }
 
-  async getContrAgentAddress(personId: string | number): Promise<ContragentAddress[]> {
-    return this.axiosCall({
+  async getContrAgentAddress(personId: string | number) {
+    return await this.axiosCall<ContragentAddress[]>({
       method: Methods.GET,
       url: `/Ekk/api/Contragentinsis/Address?PersonId=${personId}`,
     });
   }
 
-  async getTaskList(data: any): Promise<{ items: TaskListItem[]; totalItems: number }> {
-    return this.axiosCall({
+  async getTaskList(data: any) {
+    return await this.axiosCall<{ items: TaskListItem[]; totalItems: number }>({
       method: Methods.POST,
       url: `/Arm/api/Bpm/TaskList`,
       data: data,
     });
   }
 
-  async getProcessHistory(id: string): Promise<TaskHistory[]> {
-    return this.axiosCall({
+  async getProcessHistory(id: string) {
+    return await this.axiosCall<TaskHistory[]>({
       url: `/Arm/api/Bpm/GetProcessHistory?processInstanceId=${id}`,
     });
   }
 
-  async registerNumber(data: RegNumberDataType): Promise<string> {
-    return this.axiosCall({
+  async registerNumber(data: RegNumberDataType) {
+    return await this.axiosCall<string>({
       method: Methods.POST,
       url: `/${this.productUrl}/api/Application/FinCenterRegNumberSave`,
       data: data,
     });
   }
 
-  async sendSms(data: SmsDataType): Promise<void> {
-    return this.axiosCall({
+  async sendSms(data: SmsDataType) {
+    return await this.axiosCall<void>({
       method: Methods.POST,
       url: '/Arm/api/Otp/SmsText',
       data: data,
     });
   }
 
-  async getUserGroups(): Promise<Item[]> {
-    return this.axiosCall({
+  async getUserGroups() {
+    return await this.axiosCall<Item[]>({
       method: Methods.GET,
       url: '/Arm/api/Bpm/TaskGroups',
     });
   }
 
-  async getOtpStatus(data: OtpDataType): Promise<boolean> {
-    return this.axiosCall({
+  async getOtpStatus(data: OtpDataType) {
+    return await this.axiosCall<boolean>({
       method: Methods.POST,
       url: '/Arm/api/Otp/OtpLifeStatus',
       data: data,
     });
   }
 
-  async sendOtp(data: OtpDataType): Promise<SendOtpResponse> {
-    return this.axiosCall({
+  async sendOtp(data: OtpDataType) {
+    return await this.axiosCall<SendOtpResponse>({
       method: Methods.POST,
       url: '/Arm/api/Otp/Get',
       data: data,
     });
   }
 
-  async checkOtp(data: { tokenId: string; phoneNumber: string; code: string }): Promise<SendOtpResponse> {
-    return this.axiosCall({
+  async checkOtp(data: { tokenId: string; phoneNumber: string; code: string }) {
+    return await this.axiosCall<SendOtpResponse>({
       method: Methods.POST,
       url: '/Arm/api/Otp/Check',
       data: data,
     });
   }
 
-  async getProcessList(): Promise<Item[]> {
-    return this.axiosCall({
+  async getProcessList() {
+    return await this.axiosCall<Item[]>({
       method: Methods.GET,
       url: '/Arm/api/Bpm/ProcessList',
     });
   }
 
-  async startApplication(data: StartApplicationType): Promise<{
-    processInstanceId: string;
-  }> {
-    return this.axiosCall({
+  async startApplication(data: StartApplicationType) {
+    return await this.axiosCall<{
+      processInstanceId: string;
+    }>({
       method: Methods.POST,
       url: `/${this.productUrl}/api/Application/StartApplication`,
       data: data,
     });
   }
 
-  async getApplicationData(id: string): Promise<any> {
-    return this.axiosCall({
+  async getApplicationData(id: string) {
+    return await this.axiosCall<any>({
       url: `/${this.productUrl}/api/Application/applicationData?Id=${id} `,
     });
   }
 
-  async getCalculation(id: string): Promise<Number> {
-    return this.axiosCall({
+  async getCalculation(id: string) {
+    return await this.axiosCall<number>({
       method: Methods.POST,
       url: `/${this.productUrl}/api/Application/Calculator?processInstanceId=${id}`,
     });
   }
 
-  async setApplication(data: { policyAppDto: PolicyAppDto; addCoversDto: AddCover[] }): Promise<void> {
-    return this.axiosCall({
+  async setApplication(data: { policyAppDto: PolicyAppDto; addCoversDto: AddCover[] }) {
+    return await this.axiosCall<void>({
       method: Methods.POST,
       url: `/${this.productUrl}/api/Application/SetApplicationData`,
       data,
@@ -408,7 +408,7 @@ export class ApiClass {
   }
 
   async deleteFile(data: any) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.POST,
       url: '/File/api/Data/DeleteFiles',
       data: data,
@@ -416,7 +416,7 @@ export class ApiClass {
   }
 
   async uploadFiles(data: any) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.POST,
       url: '/File/api/Data/UploadFiles',
       headers: {
@@ -426,8 +426,8 @@ export class ApiClass {
     });
   }
 
-  async sendTask(data: SendTask): Promise<void> {
-    return this.axiosCall({
+  async sendTask(data: SendTask) {
+    return await this.axiosCall<void>({
       method: Methods.POST,
       url: `/${this.productUrl}/api/Application/SendTask`,
       data: data,
@@ -435,7 +435,7 @@ export class ApiClass {
   }
 
   async setMember(whichMember: keyof typeof MemberCodes, data: any) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.POST,
       url: `/Arm/api/BpmMembers/Set${whichMember}`,
       data: data,
@@ -443,89 +443,89 @@ export class ApiClass {
   }
 
   async deleteMember(whichMember: keyof typeof MemberCodes, id: number | string) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.POST,
       url: `/Arm/api/BpmMembers/Delete${whichMember}/${id}`,
     });
   }
 
-  async getInvoiceData(processInstanceId: string | number): Promise<EpayResponse> {
-    return this.axiosCall({
+  async getInvoiceData(processInstanceId: string | number) {
+    return await this.axiosCall<EpayResponse>({
       method: Methods.GET,
       url: `/Arm/api/Invoice/InvoiceData?processInstanceId=${processInstanceId}`,
     });
   }
 
   async getProcessHistoryLog(historyId: string) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.GET,
       url: `/Arm/api/Bpm/ProcessHistoryLog/${historyId}`,
     });
   }
 
-  async createInvoice(processInstanceId: string | number, amount: number | string): Promise<string> {
-    return this.axiosCall({
+  async createInvoice(processInstanceId: string | number, amount: number | string) {
+    return await this.axiosCall<string>({
       method: Methods.POST,
       url: `/Arm/api/Invoice/CreateInvoice/${processInstanceId}/${amount}`,
     });
   }
 
-  async sendToEpay(processInstanceId: string | number): Promise<EpayShortResponse> {
-    return this.axiosCall({
+  async sendToEpay(processInstanceId: string | number) {
+    return await this.axiosCall<EpayShortResponse>({
       method: Methods.POST,
       url: `/Arm/api/Invoice/SendToEpay/${processInstanceId}`,
     });
   }
 
-  async signDocument(data: SignDataType[]): Promise<SignUrlType[]> {
-    return this.axiosCall({
+  async signDocument(data: SignDataType[]) {
+    return await this.axiosCall<SignUrlType[]>({
       method: Methods.POST,
       url: '/File/api/Document/SignBts',
       data: data,
     });
   }
 
-  async getSignedDocList(data: { processInstanceId: string | number }): Promise<IDocument[]> {
-    return this.axiosCall({
+  async getSignedDocList(data: { processInstanceId: string | number }) {
+    return await this.axiosCall<IDocument[]>({
       method: Methods.POST,
       url: '/File/api/Data/List',
       data: data,
     });
   }
 
-  async calculateWithoutApplication(data: RecalculationDataType, product: string | undefined | null = this.productUrl): Promise<RecalculationResponseType> {
-    return this.axiosCall({
+  async calculateWithoutApplication(data: RecalculationDataType, product: string | undefined | null = this.productUrl) {
+    return await this.axiosCall<RecalculationResponseType>({
       method: Methods.POST,
       url: `/${product}/api/Application/Calculate`,
       data: data,
     });
   }
 
-  async getDefaultCalculationData(product: string | undefined | null = this.productUrl): Promise<RecalculationDataType> {
-    return this.axiosCall({
+  async getDefaultCalculationData(product: string | undefined | null = this.productUrl) {
+    return await this.axiosCall<RecalculationDataType>({
       method: Methods.GET,
       url: `/${product}/api/Application/DefaultCalculatorValues`,
     });
   }
 
   async reCalculate(data: any) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.POST,
       url: `/${this.productUrl}/api/Application/Recalculate`,
       data: data,
     });
   }
 
-  async getValidateClientESBD(data: ESBDValidationType): Promise<ESBDResponseType> {
-    return this.axiosCall({
+  async getValidateClientESBD(data: ESBDValidationType) {
+    return await this.axiosCall<ESBDResponseType>({
       method: Methods.POST,
       url: '/externalservices/api/ExternalServices/GetValidateClientEsbd',
       data: data,
     });
   }
 
-  async isClaimTask(taskId: string): Promise<boolean> {
-    return this.axiosCall({
+  async isClaimTask(taskId: string) {
+    return await this.axiosCall<boolean>({
       method: Methods.POST,
       url: '/Arm/api/Bpm/IsClaimTask',
       params: { TaskId: taskId },
@@ -533,23 +533,23 @@ export class ApiClass {
   }
 
   async claimTask(taskId: string) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.POST,
       url: '/Arm/api/Bpm/ClaimTaskUser',
       params: { TaskId: taskId },
     });
   }
 
-  async getContragentFromGBDFL(data: { iin: string; phoneNumber: string }): Promise<GBDFLResponse> {
-    return this.axiosCall({
+  async getContragentFromGBDFL(data: { iin: string; phoneNumber: string }) {
+    return await this.axiosCall<GBDFLResponse>({
       method: Methods.POST,
       url: '/externalservices/api/ExternalServices/GetGbdflToken',
       data: data,
     });
   }
 
-  async getFamilyInfo(data: { iin: string; phoneNumber: string }): Promise<FamilyInfoGKB> {
-    return this.axiosCall({
+  async getFamilyInfo(data: { iin: string; phoneNumber: string }) {
+    return await this.axiosCall<FamilyInfoGKB>({
       method: Methods.POST,
       url: '/externalservices/api/ExternalServices/GetFamilyInfoToken',
       data: data,
@@ -557,11 +557,11 @@ export class ApiClass {
   }
 
   async getProcessTariff(code: number | string = 5) {
-    return this.axiosCall({ url: `/Arm/api/Dictionary/ProcessTariff/${code}` });
+    return await this.axiosCall({ url: `/Arm/api/Dictionary/ProcessTariff/${code}` });
   }
 
   async setConfirmation(data: any) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.POST,
       url: '/Arm/api/UnderwritingCouncil/SetConfirmation',
       data: data,
@@ -569,51 +569,51 @@ export class ApiClass {
   }
 
   async getUnderwritingCouncilData(id: string | number) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.GET,
       url: `/Arm/api/UnderwritingCouncil/ApplicationData?Id=${id}`,
     });
   }
 
-  async sendUnderwritingCouncilTask(data: Partial<SendTask>): Promise<void> {
-    return this.axiosCall({
+  async sendUnderwritingCouncilTask(data: Partial<SendTask>) {
+    return await this.axiosCall<void>({
       method: Methods.POST,
       url: '/Arm/api/UnderwritingCouncil/SendTask',
       data: data,
     });
   }
 
-  async getDictionaryItems(dictName: string): Promise<Value[]> {
-    return this.axiosCall({
+  async getDictionaryItems(dictName: string) {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: `/Ekk/api/ContragentInsis/DictionaryItems/${dictName}`,
     });
   }
 
-  async filterManagerByRegion(dictName: string, filterName: string): Promise<Value[]> {
-    return this.axiosCall({
+  async filterManagerByRegion(dictName: string, filterName: string) {
+    return await this.axiosCall<Value[]>({
       method: Methods.GET,
       url: `/Ekk/api/ContragentInsis/DictionaryItems/${dictName}?filter=${filterName}`,
     });
   }
 
   async setINSISWorkData(data: InsisWorkDataApp) {
-    return this.axiosCall({
+    return await this.axiosCall({
       method: Methods.POST,
       url: `/Arm/api/Bpm/SetInsisWorkData`,
       data: data,
     });
   }
 
-  async searchAgentByName(name: string): Promise<AgentData[]> {
-    return this.axiosCall({
+  async searchAgentByName(name: string) {
+    return await this.axiosCall<AgentData[]>({
       method: Methods.GET,
       url: `/Ekk/api/ContragentInsis/AgentByName?fullName=${name}`,
     });
   }
 
-  async isCourseChanged(processInstanceId: string): Promise<boolean> {
-    return this.axiosCall({
+  async isCourseChanged(processInstanceId: string) {
+    return await this.axiosCall<boolean>({
       method: Methods.GET,
       url: `/${this.productUrl}/api/Application/IsCourseChanged?processInstanceId=${processInstanceId}`,
     });