@hapl/api-queries 0.2.101 → 0.2.102--canary.230.3901e87.0

package/src/clients/v1/api/crossSale/updateCrossSale.ts

@@ -0,0 +1,47 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { CrossSale, CrossSaleContractorType } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: CrossSale };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type UpdateCrossSaleUrlParams = { serviceRequestId: number; realtyId: number };
+export type UpdateCrossSaleHeaders = { 'x-auth-hc': string };
+export type UpdateCrossSaleBody = {
+  contractorType?: CrossSaleContractorType | null;
+  phone?: { number: string } | null;
+  commission?: number;
+  comment?: string | null;
+};
+export type UpdateCrossSaleData = AxiosResponse<ResultData>;
+export type UpdateCrossSaleError = AxiosError<ResultError>;
+export type UpdateCrossSaleConfig = {
+  baseURL?: string;
+  urlParams: UpdateCrossSaleUrlParams;
+  headers: UpdateCrossSaleHeaders;
+  body: UpdateCrossSaleBody;
+};
+
+export function updateCrossSaleRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  body,
+  headers,
+}: UpdateCrossSaleConfig) {
+  return axios
+    .patch(`/api/cross-sale/${urlParams.serviceRequestId}/realty/${urlParams.realtyId}`, body, {
+      baseURL,
+      headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: UpdateCrossSaleData) => res)
+    .catch((err: UpdateCrossSaleError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/currency/getCurrencyCourses.ts

@@ -1,5 +1,6 @@
 import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
 import { CurrencyCourses } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
 
 type SuccessData = { success: true; data: CurrencyCourses[] };
 type ErrorData = { success: false; data: { error: string } };
@@ -15,10 +16,7 @@ export type GetCurrencyCoursesConfig = {
   headers: GetCurrencyCoursesHeaders;
 };
 
-export function getCurrencyCoursesRequest({
-  baseURL = 'https://clients.homeapp.ru',
-  headers,
-}: GetCurrencyCoursesConfig) {
+export function getCurrencyCoursesRequest({ baseURL = DEFAULT_BASE_URL, headers }: GetCurrencyCoursesConfig) {
   return axios
     .get('/api/currency-rate/get-last-available', {
       baseURL,

package/src/clients/v1/api/currency/getRubleAmount.ts

@@ -1,5 +1,6 @@
 import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
 import { MoneyAmount } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
 
 type SuccessData = { success: true; data: MoneyAmount };
 type ErrorData = { success: false; data: { error: string } };
@@ -17,7 +18,7 @@ export type GetRubleAmountConfig = {
   headers: GetRubleAmountHeaders;
 };
 
-export function getRubleAmountRequest({ baseURL = 'https://clients.homeapp.ru', body, headers }: GetRubleAmountConfig) {
+export function getRubleAmountRequest({ baseURL = DEFAULT_BASE_URL, body, headers }: GetRubleAmountConfig) {
   return axios
     .post('/api/money/add-up', body, {
       baseURL,

package/src/clients/v1/api/deal/createDeal.ts

@@ -0,0 +1,55 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Deal, DealParticipant } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Deal };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type CreateDealHeaders = { 'x-auth-hc': string };
+export type CreateDealBody = {
+  invest: { isInvestBuyout: boolean } | null;
+  participants: Partial<DealParticipant>[];
+  clientCommission: NonNullable<Deal['clientCommission']>;
+
+  plannedCommission?: NonNullable<Deal['plannedCommission']>;
+  buyer?: { id?: number; name: string; phone: string };
+  buyParams?: { address?: string; flatNumber?: number; cadastralNumber?: string };
+  comment?: Deal['comment'];
+  companyDedicatedCommission?: Deal['companyDedicatedCommission'];
+  contract?: Pick<NonNullable<Deal['contract']>, 'id'>;
+  dealSignPlannedAt?: Deal['dealSignPlannedAt'];
+  developerCommission?: Deal['developerCommission'];
+  finalPrice?: Deal['finalPrice'];
+  hasPrepayment?: Deal['hasPrepayment'];
+  partnerCommission?: Deal['partnerCommission'];
+  partnerDealType?: Deal['partnerDealType'];
+  prepaymentPlannedAt?: Deal['prepaymentPlannedAt'];
+  prepaymentPlannedPlace?: Deal['prepaymentPlannedPlace'];
+};
+
+export type CreateDealData = AxiosResponse<ResultData>;
+export type CreateDealError = AxiosError<ResultError>;
+export type CreateDealConfig = {
+  baseURL?: string;
+  headers: CreateDealHeaders;
+  body: CreateDealBody;
+};
+
+export function createDealRequest({ baseURL = DEFAULT_BASE_URL, body, headers }: CreateDealConfig) {
+  return axios
+    .post(`/api/deal`, body, {
+      baseURL,
+      headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: CreateDealData) => res)
+    .catch((err: CreateDealError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/createDealCategorizedFile.ts

@@ -0,0 +1,54 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { DealCategorizedFile, DealCategorizedFileCategory } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: DealCategorizedFile };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type CreateDealCategorizedFileHeaders = { 'x-auth-hc': string };
+export type CreateDealCategorizedFileUrlParams = { id: number };
+export type CreateDealCategorizedFileBody = {
+  file: { id: number };
+  category: Exclude<
+    DealCategorizedFileCategory,
+    | DealCategorizedFileCategory.Act
+    | DealCategorizedFileCategory.ActDeveloper
+    | DealCategorizedFileCategory.Risk
+    | DealCategorizedFileCategory.DeleteReason
+    | DealCategorizedFileCategory.OwnershipTransfers
+    | DealCategorizedFileCategory.Egrn
+  >;
+};
+
+export type CreateDealCategorizedFileData = AxiosResponse<ResultData>;
+export type CreateDealCategorizedFileError = AxiosError<ResultError>;
+export type CreateDealCategorizedFileConfig = {
+  baseURL?: string;
+  urlParams: CreateDealCategorizedFileUrlParams;
+  headers: CreateDealCategorizedFileHeaders;
+  body: CreateDealCategorizedFileBody;
+};
+
+export function createDealCategorizedFileRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  body,
+  headers,
+}: CreateDealCategorizedFileConfig) {
+  return axios
+    .post(`/api/deal/${urlParams.id}/file`, body, {
+      baseURL,
+      headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data?.error),
+      ],
+    })
+    .then((res: CreateDealCategorizedFileData) => res)
+    .catch((err: CreateDealCategorizedFileError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/createDealInvestPrepayment.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Deal } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Partial<Deal> & { id: number } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type CreateDealInvestPrepaymentHeaders = { 'x-auth-hc': string };
+export type CreateDealInvestPrepaymentUrlParams = { id: number };
+export type CreateDealInvestPrepaymentBody = { investBuyoutPrepaymentSum: number; investBuyoutPrepaymentAt: string };
+export type CreateDealInvestPrepaymentData = AxiosResponse<ResultData>;
+export type CreateDealInvestPrepaymentError = AxiosError<ResultError>;
+export type CreateDealInvestPrepaymentConfig = {
+  baseURL?: string;
+  urlParams: CreateDealInvestPrepaymentUrlParams;
+  headers: CreateDealInvestPrepaymentHeaders;
+  body: CreateDealInvestPrepaymentBody;
+};
+
+export function createDealInvestPrepaymentRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers,
+  body,
+}: CreateDealInvestPrepaymentConfig) {
+  return axios
+    .patch(`/api/deal/invest-prepayment/${urlParams.id}`, body, {
+      baseURL,
+      headers: { Accept: 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: CreateDealInvestPrepaymentData) => res)
+    .catch((err: CreateDealInvestPrepaymentError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/deleteDealCategorizedFile.ts

@@ -0,0 +1,38 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = never;
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = null;
+type ResultError = ErrorData['data']['error'];
+
+export type DeleteDealCategorizedFileHeaders = { 'x-auth-hc': string };
+export type DeleteDealCategorizedFileUrlParams = { dealId: number; id: number };
+export type DeleteDealCategorizedFileData = AxiosResponse<ResultData>;
+export type DeleteDealCategorizedFileError = AxiosError<ResultError>;
+export type DeleteDealCategorizedFileConfig = {
+  baseURL?: string;
+  urlParams: DeleteDealCategorizedFileUrlParams;
+  headers: DeleteDealCategorizedFileHeaders;
+};
+
+export function deleteDealCategorizedFileRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers,
+}: DeleteDealCategorizedFileConfig) {
+  return axios
+    .delete(`/api/deal/${urlParams.dealId}/file/${urlParams.id}`, {
+      baseURL,
+      headers: { Accept: 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data && !data.success ? data.data?.error : null),
+      ],
+    })
+    .then((res: DeleteDealCategorizedFileData) => res)
+    .catch((err: DeleteDealCategorizedFileError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/findDealById.ts

@@ -0,0 +1,36 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Deal } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Deal };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type FindDealByIdUrlParams = { id: number };
+export type FindDealByIdHeaders = { 'x-auth-hc': string };
+export type FindDealByIdData = AxiosResponse<ResultData>;
+export type FindDealByIdError = AxiosError<ResultError>;
+
+export type FindDealByIdConfig = {
+  baseURL?: string;
+  urlParams: FindDealByIdUrlParams;
+  headers: FindDealByIdHeaders;
+};
+
+export function findDealByIdRequest({ baseURL = DEFAULT_BASE_URL, urlParams, headers }: FindDealByIdConfig) {
+  return axios
+    .get(`/api/deal/${urlParams.id}`, {
+      baseURL,
+      headers: { Accept: 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: FindDealByIdData) => res)
+    .catch((err: FindDealByIdError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/findDealCategorizedFiles.ts

@@ -0,0 +1,65 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { DealCategorizedFile } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: DealCategorizedFile[]; pageParams: { page: number; length: number } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = { ids: number[]; byId: Record<string, DealCategorizedFile>; meta: { total: number } };
+type ResultError = string;
+
+export type FindDealCategorizedFilesHeaders = { 'x-auth-hc': string };
+export type FindDealCategorizedFilesUrlParams = { id: number };
+export type FindDealCategorizedFilesParams = {
+  filter?: {
+    id?: number | number[];
+  };
+  limits?: { page?: number; count: number | 'all' };
+  sorting?: { direction: 'asc' | 'desc'; type: 'file.createdAt' };
+};
+export type FindDealCategorizedFilesData = AxiosResponse<ResultData>;
+export type FindDealCategorizedFilesError = AxiosError<ResultError>;
+export type FindDealCategorizedFilesConfig = {
+  baseURL?: string;
+  urlParams: FindDealCategorizedFilesUrlParams;
+  headers: FindDealCategorizedFilesHeaders;
+  params: FindDealCategorizedFilesParams;
+};
+
+export function findDealCategorizedFilesRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers,
+  params,
+}: FindDealCategorizedFilesConfig) {
+  return axios
+    .get(`/api/deal/${urlParams.id}/file`, {
+      baseURL,
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'brackets' }),
+      headers: { Accept: 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (data.success) {
+            const ids: ResultData['ids'] = [];
+            const byId: ResultData['byId'] = {};
+
+            data.data.forEach(entity => {
+              byId[entity.id] = entity;
+              ids.push(entity.id);
+            });
+
+            return { ids, byId, meta: { total: data.pageParams.length } };
+          }
+
+          return data.data?.error;
+        },
+      ],
+    })
+    .then((res: FindDealCategorizedFilesData) => res)
+    .catch((err: FindDealCategorizedFilesError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/findDealExpertStatistics.ts

@@ -0,0 +1,44 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: { month: string; count: number; commission: number }[] };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type FindDealExpertStatisticsParams = { filter?: { from: string; to: string } };
+export type FindDealExpertStatisticsUrlParams = { id: number };
+export type FindDealExpertStatisticsHeaders = { 'x-auth-hc': string };
+export type FindDealExpertStatisticsData = AxiosResponse<ResultData>;
+export type FindDealExpertStatisticsError = AxiosError<ResultError>;
+export type FindDealExpertStatisticsConfig = {
+  baseURL?: string;
+  headers: FindDealExpertStatisticsHeaders;
+  params: FindDealExpertStatisticsParams;
+  urlParams: FindDealExpertStatisticsUrlParams;
+};
+
+export function findDealExpertStatisticsRequest({
+  baseURL = DEFAULT_BASE_URL,
+  headers,
+  params,
+  urlParams,
+}: FindDealExpertStatisticsConfig) {
+  return axios
+    .get(`/api/deal/${urlParams.id}/expert-statistic`, {
+      baseURL,
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'brackets' }),
+      headers: { Accept: 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: FindDealExpertStatisticsData) => res)
+    .catch((err: FindDealExpertStatisticsError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/findDeals.ts

@@ -0,0 +1,109 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { ContractStatus, Deal, DealStatus, ServiceRequestType } from '../../types';
+import { RealtyType } from '../../../v2';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = {
+  success: true;
+  data: Deal[];
+  meta: { plannedCommissionSum: number; receivedCommissionSum: number };
+  pageParams: { page: number; length: number };
+};
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = {
+  ids: number[];
+  byId: Record<string, Deal>;
+  meta: { total: number; plannedCommissionSum: number; receivedCommissionSum: number };
+};
+type ResultError = ErrorData['data']['error'];
+
+export type FindDealsParams = {
+  filter?: {
+    actSignedAt?: { from?: string; to?: string };
+    address?: string;
+    'contract.serviceRequest.curator.office'?: string;
+    'contract.serviceRequest.id'?: number | 'null' | 'notnull';
+    'contract.serviceRequest.investBuyoutDeal.id'?: number | 'null' | 'notnull';
+    'contract.serviceRequest.realtyType'?: RealtyType;
+    'contract.serviceRequest.type'?: ServiceRequestType;
+    'contract.signedAt'?: { from?: string; to?: string };
+    'contract.status'?: ContractStatus;
+    commonId?: string;
+    createdAt?: { from?: string; to?: string };
+    dealDoneAt?: { from?: string; to?: string };
+    dealSignedAt?: { from?: string; to?: string };
+    'expert.id'?: number | 'null' | 'notnull';
+    'expert.supervisor.id'?: number | 'null' | 'notnull';
+    financeConfirmAt?: { from?: string; to?: string } | 'null' | 'notnull';
+    hasPassedDate?: boolean;
+    hasPrepayment?: boolean;
+    id?: number | number[] | 'null' | 'notnull';
+    isInvestBuyout?: boolean;
+    isLawyerRequired?: boolean;
+    'lawyer.id'?: number | 'null' | 'notnull';
+    lawyerNotRequiredReason?: string;
+    prepaidAt?: { from?: string; to?: string };
+    prepaymentPlannedAt?: { from?: string; to?: string };
+    registeredAt?: { from?: string; to?: string };
+    status?: DealStatus | DealStatus[];
+    terminatedAt?: { from?: string; to?: string };
+    withTerminated?: boolean;
+  };
+  limits?: { page?: number; count: number | 'all' };
+  sorting?: {
+    direction: 'asc' | 'desc';
+    type:
+      | 'commissionAt'
+      | 'commissionPlannedAt'
+      | 'createdAt'
+      | 'dealDoneAt'
+      | 'dealSignPlannedAt'
+      | 'dealSignedAt'
+      | 'prepaidAt'
+      | 'prepaymentPlannedAt'
+      | 'registerPlannedAt'
+      | 'registeredAt'
+      | 'terminationRequestedAt';
+  };
+};
+
+export type FindDealsHeaders = { 'x-auth-hc': string };
+export type FindDealsData = AxiosResponse<ResultData>;
+export type FindDealsError = AxiosError<ResultError>;
+export type FindDealsConfig = {
+  baseURL?: string;
+  headers: FindDealsHeaders;
+  params: FindDealsParams;
+};
+
+export function findDealsRequest({ baseURL = DEFAULT_BASE_URL, headers, params }: FindDealsConfig) {
+  return axios
+    .get('/api/deal', {
+      baseURL,
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'brackets' }),
+      headers: { Accept: 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (!data.success) return data.data.error;
+
+          const ids: ResultData['ids'] = [];
+          const byId: ResultData['byId'] = {};
+
+          data.data.forEach(entity => {
+            byId[entity.id] = entity;
+            ids.push(entity.id);
+          });
+
+          return { ids, byId, meta: { ...data.meta, total: data.pageParams.length } };
+        },
+      ],
+    })
+    .then((res: FindDealsData) => res)
+    .catch((err: FindDealsError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/setDealClassificationScore.ts

@@ -0,0 +1,43 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Deal } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Partial<Deal> & { id: number } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type SetDealClassificationScoreHeaders = { 'x-auth-hc': string };
+export type SetDealClassificationScoreUrlParams = { id: number };
+export type SetDealClassificationScoreBody = { dealId: number; classificationScore: number };
+
+export type SetDealClassificationScoreData = AxiosResponse<ResultData>;
+export type SetDealClassificationScoreError = AxiosError<ResultError>;
+export type SetDealClassificationScoreConfig = {
+  baseURL?: string;
+  urlParams: SetDealClassificationScoreUrlParams;
+  headers: SetDealClassificationScoreHeaders;
+  body: SetDealClassificationScoreBody;
+};
+
+export function setDealClassificationScoreRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers,
+  body,
+}: SetDealClassificationScoreConfig) {
+  return axios
+    .post(`/api/deal/classification-score/${urlParams.id}`, body, {
+      baseURL,
+      headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: SetDealClassificationScoreData) => res)
+    .catch((err: SetDealClassificationScoreError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/setDealDoneState.ts

@@ -0,0 +1,36 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Deal } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Partial<Deal> & { id: number } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type SetDealDoneStateUrlParams = { id: number };
+export type SetDealDoneStateHeaders = { 'x-auth-hc': string };
+
+export type SetDealDoneStateData = AxiosResponse<ResultData>;
+export type SetDealDoneStateError = AxiosError<ResultError>;
+export type SetDealDoneStateConfig = {
+  baseURL?: string;
+  urlParams: SetDealDoneStateUrlParams;
+  headers: SetDealDoneStateHeaders;
+};
+
+export function setDealDoneStateRequest({ baseURL = DEFAULT_BASE_URL, urlParams, headers }: SetDealDoneStateConfig) {
+  return axios
+    .patch(`/api/deal/status/deal-done/${urlParams.id}`, null, {
+      baseURL,
+      headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: SetDealDoneStateData) => res)
+    .catch((err: SetDealDoneStateError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/deal/setDealFinanceConfirmState.ts

@@ -0,0 +1,40 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Deal } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Partial<Deal> & { id: number } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type SetDealFinanceConfirmStateUrlParams = { id: number };
+export type SetDealFinanceConfirmStateHeaders = { 'x-auth-hc': string };
+
+export type SetDealFinanceConfirmStateData = AxiosResponse<ResultData>;
+export type SetDealFinanceConfirmStateError = AxiosError<ResultError>;
+export type SetDealFinanceConfirmStateConfig = {
+  baseURL?: string;
+  urlParams: SetDealFinanceConfirmStateUrlParams;
+  headers: SetDealFinanceConfirmStateHeaders;
+};
+
+export function setDealFinanceConfirmStateRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers,
+}: SetDealFinanceConfirmStateConfig) {
+  return axios
+    .patch(`/api/deal/status/finance-confirm/${urlParams.id}`, null, {
+      baseURL,
+      headers: { Accept: 'application/json', 'Content-Type': 'application/json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: SetDealFinanceConfirmStateData) => res)
+    .catch((err: SetDealFinanceConfirmStateError) => {
+      throw err;
+    });
+}