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

package/src/clients/v1/api/task/updateTask.ts

@@ -0,0 +1,44 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Task, TaskImportance, TaskNotificationType } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Task };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type UpdateTaskUrlParams = { id: number };
+export type UpdateTaskHeaders = { 'x-auth-hc': string };
+export type UpdateTaskBody = {
+  expiresAt: string;
+  importance: TaskImportance;
+  notificationType: TaskNotificationType;
+  serviceRequest: { id: number };
+  text: string;
+};
+
+export type UpdateTaskData = AxiosResponse<ResultData>;
+export type UpdateTaskError = AxiosError<ResultError>;
+export type UpdateTaskConfig = {
+  baseURL?: string;
+  urlParams: UpdateTaskUrlParams;
+  headers: UpdateTaskHeaders;
+  body: UpdateTaskBody;
+};
+
+export function updateTaskRequest({ baseURL = DEFAULT_BASE_URL, urlParams, body, headers }: UpdateTaskConfig) {
+  return axios
+    .put(`/api/task/${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: UpdateTaskData) => res)
+    .catch((err: UpdateTaskError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/assignSubordinateUsers.ts

@@ -0,0 +1,41 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: number[] };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type AssignSubordinateUsersUrlParams = { id: number };
+export type AssignSubordinateUsersHeaders = { 'x-auth-hc': string };
+export type AssignSubordinateUsersBody = { userIds: number[] };
+export type AssignSubordinateUsersData = AxiosResponse<ResultData>;
+export type AssignSubordinateUsersError = AxiosError<ResultError>;
+export type AssignSubordinateUsersConfig = {
+  baseURL?: string;
+  urlParams: AssignSubordinateUsersUrlParams;
+  headers: AssignSubordinateUsersHeaders;
+  body: AssignSubordinateUsersBody;
+};
+
+export function assignSubordinateUsersRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  body,
+  headers,
+}: AssignSubordinateUsersConfig) {
+  return axios
+    .put(`/api/user/supervise/${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: AssignSubordinateUsersData) => res)
+    .catch((err: AssignSubordinateUsersError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/createUser.ts

@@ -0,0 +1,43 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { User, Contact, UserPhone } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Partial<User> & { id: number } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type CreateUserHeaders = { 'x-auth-hc': string };
+export type CreateUserBody = Partial<
+  Omit<
+    User,
+    | 'id'
+    | 'contactInfo'
+    | 'createdAt'
+    | 'defaultVirtualPhone'
+    | 'phones'
+    | 'realtyIds'
+    | 'transliteratedFullName'
+    | 'updatedAt'
+  >
+> & { login: string; contactInfo?: Array<Omit<Contact, 'id'>>; phones?: Array<Omit<UserPhone, 'id'>> };
+export type CreateUserData = AxiosResponse<ResultData>;
+export type CreateUserError = AxiosError<ResultError>;
+export type CreateUserConfig = { baseURL?: string; headers: CreateUserHeaders; body: CreateUserBody };
+
+export function createUserRequest({ baseURL = DEFAULT_BASE_URL, headers, body }: CreateUserConfig) {
+  return axios
+    .post('/api/user', 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: CreateUserData) => res)
+    .catch((err: CreateUserError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/deleteUser.ts

@@ -0,0 +1,35 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { User } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: User };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type DeleteUserHeaders = { 'x-auth-hc': string };
+export type DeleteUserUrlParams = { id: number };
+export type DeleteUserData = AxiosResponse<ResultData>;
+export type DeleteUserError = AxiosError<ResultError>;
+export type DeleteUserConfig = {
+  baseURL?: string;
+  urlParams: DeleteUserUrlParams;
+  headers: DeleteUserHeaders;
+};
+
+export function deleteUserRequest({ baseURL = DEFAULT_BASE_URL, urlParams, headers }: DeleteUserConfig) {
+  return axios
+    .patch(`/api/user/delete/${urlParams.id}`, null, {
+      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: DeleteUserData) => res)
+    .catch((err: DeleteUserError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/findUserById.ts

@@ -0,0 +1,31 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { User } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Partial<User> & { id: number } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type FindUserByIdUrlParams = { id: number };
+export type FindUserByIdHeaders = { 'x-auth-hc'?: string };
+export type FindUserByIdData = AxiosResponse<ResultData>;
+export type FindUserByIdError = AxiosError<ResultError>;
+export type FindUserByIdConfig = { baseURL?: string; urlParams: FindUserByIdUrlParams; headers?: FindUserByIdHeaders };
+
+export function findUserByIdRequest({ baseURL = DEFAULT_BASE_URL, urlParams, headers = {} }: FindUserByIdConfig) {
+  return axios
+    .get(`/api/user/${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: FindUserByIdData) => res)
+    .catch((err: FindUserByIdError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/findUserPasswordById.ts

@@ -0,0 +1,38 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: { text: string } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type FindUserPasswordByIdUrlParams = { id: number };
+export type FindUserPasswordByIdHeaders = { 'x-auth-hc'?: string };
+export type FindUserPasswordByIdData = AxiosResponse<ResultData>;
+export type FindUserPasswordByIdError = AxiosError<ResultError>;
+export type FindUserPasswordByIdConfig = {
+  baseURL?: string;
+  urlParams: FindUserPasswordByIdUrlParams;
+  headers?: FindUserPasswordByIdHeaders;
+};
+
+export function findUserPasswordByIdRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers,
+}: FindUserPasswordByIdConfig) {
+  return axios
+    .get(`/api/user/password/${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: FindUserPasswordByIdData) => res)
+    .catch((err: FindUserPasswordByIdError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/findUserTokenById.ts

@@ -0,0 +1,34 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: { key: string } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type FindUserTokenByIdUrlParams = { id: number };
+export type FindUserTokenByIdHeaders = { 'x-auth-hc'?: string };
+export type FindUserTokenByIdData = AxiosResponse<ResultData>;
+export type FindUserTokenByIdError = AxiosError<ResultError>;
+export type FindUserTokenByIdConfig = {
+  baseURL?: string;
+  urlParams: FindUserTokenByIdUrlParams;
+  headers?: FindUserTokenByIdHeaders;
+};
+
+export function findUserTokenByIdRequest({ baseURL = DEFAULT_BASE_URL, urlParams, headers }: FindUserTokenByIdConfig) {
+  return axios
+    .get(`/api/session/token/${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: FindUserTokenByIdData) => res)
+    .catch((err: FindUserTokenByIdError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/findUsers.ts

@@ -0,0 +1,69 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { User, UserRole } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = {
+  success: true;
+  data: User[];
+  pageParams: { page: number; length: number };
+};
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = { ids: number[]; byId: Record<string, User>; meta: { total: number } };
+type ResultError = string;
+
+export type FindUsersHeaders = { 'x-auth-hc': string };
+export type FindUsersParams = {
+  filter?: {
+    banned?: boolean;
+    enabled?: boolean;
+    fullName?: string;
+    id?: number | number[];
+    login?: string;
+    phone?: number;
+    'supervisor.id'?: number;
+    'roles.role'?: UserRole[];
+    mentor?: number;
+    experts?: number;
+    personalAssistants?: number;
+  };
+  limits?: { page?: number; count: number | 'all' };
+  sorting?: {
+    direction: 'asc' | 'desc';
+    type: 'createdAt' | 'firstName' | 'lastName' | 'hiredAt' | 'firedAt' | 'updatedAt' | 'id' | 'login';
+  };
+};
+export type FindUsersData = AxiosResponse<ResultData>;
+export type FindUsersError = AxiosError<ResultError>;
+export type FindUsersConfig = { baseURL?: string; headers: FindUsersHeaders; params: FindUsersParams };
+
+export function findUsersRequest({ baseURL = DEFAULT_BASE_URL, headers, params }: FindUsersConfig) {
+  return axios
+    .get('/api/user', {
+      baseURL,
+      headers: { Accept: 'application/json', ...headers },
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'brackets' }),
+      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: { total: data.pageParams.length } };
+        },
+      ],
+    })
+    .then((res: FindUsersData) => res)
+    .catch((err: FindUsersError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/fireUser.ts

@@ -0,0 +1,43 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { User } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: unknown[] };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = null;
+type ResultError = ErrorData['data']['error'];
+
+export type FireUserUrlParams = { id: number };
+export type FireUserHeaders = { 'x-auth-hc': string };
+export type FireUserBody = {
+  firedAt: NonNullable<NonNullable<User['employeeInfo']>['firedAt']>;
+  firedType?: NonNullable<User['employeeInfo']>['firedType'];
+  firedReason?: NonNullable<User['employeeInfo']>['firedReason'];
+  firedComment?: NonNullable<User['employeeInfo']>['firedComment'];
+};
+
+export type FireUserData = AxiosResponse<ResultData>;
+export type FireUserError = AxiosError<ResultError>;
+export type FireUserConfig = {
+  baseURL?: string;
+  urlParams: FireUserUrlParams;
+  headers: FireUserHeaders;
+  body: FireUserBody;
+};
+
+export function fireUserRequest({ baseURL = DEFAULT_BASE_URL, urlParams, headers, body }: FireUserConfig) {
+  return axios
+    .patch(`/api/user/fire/${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 ? null : data.data.error),
+      ],
+    })
+    .then((res: FireUserData) => res)
+    .catch((err: FireUserError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/user/updateUser.ts

@@ -0,0 +1,72 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { User, UserPhone, Contact } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Partial<User> & { id: number } };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type UpdateUserUrlParams = { id: number };
+export type UpdateUserHeaders = { 'x-auth-hc': string };
+export type UpdateUserBody = {
+  banned?: Required<User>['banned'];
+  bornAt?: Required<User>['bornAt'];
+  cases?: Required<User>['cases'];
+  comment?: Required<User>['comment'];
+  contactInfo?: Array<Omit<Contact, 'id'>>;
+  courses?: Required<User>['courses'];
+  defaultTelephony?: Required<User>['defaultTelephony'] | null;
+  description?: Required<User>['description'];
+  direction?: Required<User>['direction'];
+  districts?: Required<User>['districts'];
+  educations?: Required<User>['educations'];
+  employeeInfo?: Required<User>['employeeInfo'];
+  enabled?: Required<User>['enabled'];
+  firstName?: Required<User>['firstName'] | null;
+  gallery?: Required<User>['gallery'];
+  gender?: Required<User>['gender'];
+  groupLead?: Required<User>['groupLead'] | null;
+  hiredAt?: Required<User>['hiredAt'];
+  isPublished?: Required<User>['isPublished'];
+  lastName?: Required<User>['lastName'] | null;
+  level?: Required<User>['level'];
+  login?: Required<User>['login'];
+  mentor?: Required<User>['mentor'] | null;
+  office?: Required<User>['office'];
+  patronymic?: Required<User>['patronymic'] | null;
+  phones?: Array<Omit<UserPhone, 'id'>>;
+  roles?: Required<User>['roles'];
+  supervisor?: Required<User>['supervisor'] | null;
+  textReviews?: Required<User>['textReviews'];
+  videoReviews?: Required<User>['videoReviews'];
+  personalAssistants?: Array<{ id: number }>;
+  companies?: Array<{ id: number; isMain: boolean }>;
+};
+
+export type UpdateUserData = AxiosResponse<ResultData>;
+export type UpdateUserError = AxiosError<ResultError>;
+
+export type UpdateUserConfig = {
+  baseURL?: string;
+  urlParams: UpdateUserUrlParams;
+  headers: UpdateUserHeaders;
+  body: UpdateUserBody;
+};
+
+export function updateUserRequest({ baseURL = DEFAULT_BASE_URL, urlParams, headers, body }: UpdateUserConfig) {
+  return axios
+    .patch(`/api/user/${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: UpdateUserData) => res)
+    .catch((err: UpdateUserError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/valuation/actualizeValuation.ts

@@ -0,0 +1,39 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Valuation } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Valuation };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type ActualizeValuationHeaders = { 'x-auth-hc': string };
+export type ActualizeValuationUrlParams = { serviceRequestId: number };
+export type ActualizeValuationData = AxiosResponse<ResultData>;
+export type ActualizeValuationError = AxiosError<ResultError>;
+export type ActualizeValuationConfig = {
+  baseURL?: string;
+  urlParams: ActualizeValuationUrlParams;
+  headers: ActualizeValuationHeaders;
+};
+
+export function actualizeValuationRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers,
+}: ActualizeValuationConfig) {
+  return axios
+    .patch(`/api/valuation/${urlParams.serviceRequestId}/actualize`, null, {
+      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: ActualizeValuationData) => res)
+    .catch((err: ActualizeValuationError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/valuation/createValuation.ts

@@ -0,0 +1,45 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Valuation } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Valuation };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type CreateValuationHeaders = { 'x-auth-hc': string };
+export type CreateValuationBody = Partial<{
+  serviceRequest: NonNullable<Valuation['serviceRequest']>;
+  addresses: Valuation['addresses'];
+  calculationData: Valuation['calculationData'];
+  comment: Valuation['comment'];
+  filter: Valuation['filter'];
+  isDraft: Valuation['isDraft'];
+  isOnlyInMarketRangeShown: Valuation['isOnlyInMarketRangeShown'];
+  realtyParams: Valuation['realtyParams'];
+}>;
+
+export type CreateValuationData = AxiosResponse<ResultData>;
+export type CreateValuationError = AxiosError<ResultError>;
+export type CreateValuationConfig = {
+  baseURL?: string;
+  headers: CreateValuationHeaders;
+  body: CreateValuationBody;
+};
+
+export function createValuationRequest({ baseURL = DEFAULT_BASE_URL, body, headers }: CreateValuationConfig) {
+  return axios
+    .post('/api/valuation', 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: CreateValuationData) => res)
+    .catch((err: CreateValuationError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/valuation/createValuationRealtyComment.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = null;
+type ResultError = ErrorData['data']['error'];
+
+export type CreateValuationRealtyCommentUrlParams = { serviceRequestId: number; realtyId: number };
+export type CreateValuationRealtyCommentHeaders = { 'x-auth-hc': string };
+export type CreateValuationRealtyCommentBody = { comment: string };
+
+export type CreateValuationRealtyCommentData = AxiosResponse<ResultData>;
+export type CreateValuationRealtyCommentError = AxiosError<ResultError>;
+export type CreateValuationRealtyCommentConfig = {
+  baseURL?: string;
+  urlParams: CreateValuationRealtyCommentUrlParams;
+  headers: CreateValuationRealtyCommentHeaders;
+  body: CreateValuationRealtyCommentBody;
+};
+
+export function createValuationRealtyCommentRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  body,
+  headers,
+}: CreateValuationRealtyCommentConfig) {
+  return axios
+    .put(`/api/valuation/${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 ? null : data.data.error),
+      ],
+    })
+    .then((res: CreateValuationRealtyCommentData) => res)
+    .catch((err: CreateValuationRealtyCommentError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/valuation/findValuationByServiceRequestId.ts

@@ -0,0 +1,46 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { Valuation } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: Valuation };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type FindValuationByServiceRequestIdHeaders = { 'x-auth-hc'?: string };
+export type FindValuationByServiceRequestIdUrlParams = { id: number };
+export type FindValuationByServiceRequestIdParams = { withDrafts?: boolean };
+export type FindValuationByServiceRequestIdData = AxiosResponse<ResultData>;
+export type FindValuationByServiceRequestIdError = AxiosError<ResultError>;
+
+export type FindValuationByServiceRequestIdConfig = {
+  baseURL?: string;
+  urlParams: FindValuationByServiceRequestIdUrlParams;
+  headers?: FindValuationByServiceRequestIdHeaders;
+  params?: FindValuationByServiceRequestIdParams;
+};
+
+export function findValuationByServiceRequestIdRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers = {},
+  params,
+}: FindValuationByServiceRequestIdConfig) {
+  return axios
+    .get(`/api/valuation/${urlParams.id}`, {
+      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: FindValuationByServiceRequestIdData) => res)
+    .catch((err: FindValuationByServiceRequestIdError) => {
+      throw err;
+    });
+}

package/src/clients/v1/api/valuation/findValuationNewsByServiceRequestId.ts

@@ -0,0 +1,40 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { ValuationNews } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { success: true; data: ValuationNews[] };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type FindValuationNewsByServiceRequestIdHeaders = { 'x-auth-hc': string };
+export type FindValuationNewsByServiceRequestIdUrlParams = { serviceRequestId: number };
+export type FindValuationNewsByServiceRequestIdData = AxiosResponse<ResultData>;
+export type FindValuationNewsByServiceRequestIdError = AxiosError<ResultError>;
+
+export type FindValuationNewsByServiceRequestIdConfig = {
+  baseURL?: string;
+  urlParams: FindValuationNewsByServiceRequestIdUrlParams;
+  headers: FindValuationNewsByServiceRequestIdHeaders;
+};
+
+export function findValuationNewsByServiceRequestIdRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  headers,
+}: FindValuationNewsByServiceRequestIdConfig) {
+  return axios
+    .get(`/api/valuation/${urlParams.serviceRequestId}/news`, {
+      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: FindValuationNewsByServiceRequestIdData) => res)
+    .catch((err: FindValuationNewsByServiceRequestIdError) => {
+      throw err;
+    });
+}