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

package/src/clients/v2/api/addressBti/updateAddressBti.ts

@@ -0,0 +1,45 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { AddressBTIParams } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { data: AddressBTIParams; errors: never };
+type ErrorData = {
+  data: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['errors'];
+
+export type UpdateAddressBtiHeaders = { 'x-auth-hc': string };
+export type UpdateAddressBtiUrlParams = { id: string };
+export type UpdateAddressBtiBody = { data: Omit<AddressBTIParams, 'relationships' | 'meta'> };
+export type UpdateAddressBtiData = AxiosResponse<ResultData>;
+export type UpdateAddressBtiError = AxiosError<ResultError>;
+export type UpdateAddressBtiConfig = {
+  baseURL?: string;
+  urlParams: UpdateAddressBtiUrlParams;
+  body: UpdateAddressBtiBody;
+  headers: UpdateAddressBtiHeaders;
+};
+
+export function updateAddressBtiRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  body,
+  headers,
+}: UpdateAddressBtiConfig) {
+  return axios
+    .patch(`/api/v2/address-bti/${urlParams.id}`, body, {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json', 'Content-Type': 'application/vnd.api+json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.errors ? data.errors : data.data),
+      ],
+    })
+    .then((res: UpdateAddressBtiData) => res)
+    .catch((err: UpdateAddressBtiError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/complex/findComplexById.ts

@@ -0,0 +1,62 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { ComplexHousing, Complex } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = {
+  data: Complex;
+  included?: Array<ComplexHousing>;
+  errors: never;
+};
+type ErrorData = {
+  data: never;
+  included: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = { data: Complex; included?: SuccessData['included'] };
+type ResultError = ErrorData['errors'];
+
+export type ComplexInclude = 'complexHousing';
+
+export type FindComplexByIdHeaders = { 'x-auth-hc': string };
+export type FindComplexByIdUrlParams = { id: number };
+export type FindComplexByIdParams = { include?: Array<ComplexInclude> };
+export type FindComplexByIdData = AxiosResponse<ResultData>;
+export type FindComplexByIdError = AxiosError<ResultError>;
+export type FindComplexByIdConfig = {
+  baseURL?: string;
+  urlParams: FindComplexByIdUrlParams;
+  params?: FindComplexByIdParams;
+  headers?: FindComplexByIdHeaders;
+};
+
+export function findComplexByIdRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  params,
+  headers,
+}: FindComplexByIdConfig) {
+  return axios
+    .get(`/api/v2/complex/${urlParams.id}`, {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json', ...headers },
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'comma', skipNulls: true }),
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (data.errors) return data.errors;
+
+          return {
+            data: data.data,
+            included: data.included,
+          };
+        },
+      ],
+    })
+    .then((res: FindComplexByIdData) => res)
+    .catch((err: FindComplexByIdError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/complex/findComplexHousingByComplexId.ts

@@ -0,0 +1,65 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { ComplexHousing, Complex } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = {
+  data: ComplexHousing & { meta: { isReadonly?: boolean } };
+  included?: Complex;
+  errors: never;
+};
+type ErrorData = {
+  data: never;
+  included: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = {
+  data: ComplexHousing & { meta: SuccessData['data']['meta'] };
+  included?: SuccessData['included'];
+};
+type ResultError = ErrorData['errors'];
+
+export type ComplexHousingInclude = 'complex';
+
+export type FindComplexHousingByComplexIdHeaders = { 'x-auth-hc': string };
+export type FindComplexHousingByComplexIdUrlParams = { id: number };
+export type FindComplexHousingByComplexIdParams = { include?: Array<ComplexHousingInclude> };
+export type FindComplexHousingByComplexIdData = AxiosResponse<ResultData>;
+export type FindComplexHousingByComplexIdError = AxiosError<ResultError>;
+export type FindComplexHousingByComplexIdConfig = {
+  baseURL?: string;
+  urlParams: FindComplexHousingByComplexIdUrlParams;
+  params?: FindComplexHousingByComplexIdParams;
+  headers?: FindComplexHousingByComplexIdHeaders;
+};
+
+export function findComplexHousingByComplexIdRequest({
+  baseURL = DEFAULT_BASE_URL,
+  urlParams,
+  params,
+  headers,
+}: FindComplexHousingByComplexIdConfig) {
+  return axios
+    .get(`/api/v2/complex-housing/${urlParams.id}`, {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json', ...headers },
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'comma', skipNulls: true }),
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (data.errors) return data.errors;
+
+          return {
+            data: { ...data.data, meta: data.data.meta },
+            included: data.included,
+          };
+        },
+      ],
+    })
+    .then((res: FindComplexHousingByComplexIdData) => res)
+    .catch((err: FindComplexHousingByComplexIdError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/complex/findComplexes.ts

@@ -0,0 +1,66 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { Complex, ComplexHousing } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = {
+  data: Complex[];
+  included?: Array<ComplexHousing>;
+  meta: { page: { offset: number; count: number; total: number } };
+  errors: never;
+};
+type ErrorData = {
+  data: never;
+  included: never;
+  meta: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = {
+  ids: string[];
+  byId: Record<string, Complex>;
+  meta: SuccessData['meta'];
+  included?: SuccessData['included'];
+};
+type ResultError = ErrorData['errors'];
+
+export type FindComplexesInclude = 'complexHousing';
+export type FindComplexesParams = {
+  include?: FindComplexesInclude;
+  filter?: { name?: string };
+  page?: { offset?: number; limit?: number };
+};
+export type FindComplexesHeaders = { 'x-auth-hc'?: string };
+export type FindComplexesData = AxiosResponse<ResultData>;
+export type FindComplexesError = AxiosError<ResultError>;
+export type FindComplexesConfig = { baseURL?: string; params?: FindComplexesParams; headers?: FindComplexesHeaders };
+
+export function findComplexesRequest({ baseURL = DEFAULT_BASE_URL, params, headers }: FindComplexesConfig) {
+  return axios
+    .get('/api/v2/complex', {
+      baseURL,
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'comma', skipNulls: true }),
+      headers: { Accept: 'application/vnd.api+json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (data.errors) return data.errors;
+
+          const ids: ResultData['ids'] = [];
+          const byId: ResultData['byId'] = {};
+
+          data.data.forEach(entity => {
+            byId[entity.id] = entity;
+            ids.push(entity.id);
+          });
+
+          return { ids, byId, included: data.included, meta: data.meta };
+        },
+      ],
+    })
+    .then((res: FindComplexesData) => res)
+    .catch((err: FindComplexesError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/cottageComplex/findCottageComplexes.ts

@@ -0,0 +1,70 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import qs from 'qs';
+import { CottageComplex } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = {
+  data: CottageComplex[];
+  meta: { page: { offset: number; count: number; total: number } };
+  errors: never;
+};
+type ErrorData = {
+  data: never;
+  included: never;
+  meta: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = {
+  ids: string[];
+  byId: Record<string, CottageComplex>;
+  meta: SuccessData['meta'];
+};
+type ResultError = ErrorData['errors'];
+
+export type FindCottageComplexesParams = {
+  filter?: { name?: string };
+  page?: { offset?: number; limit?: number };
+};
+export type FindCottageComplexesHeaders = { 'x-auth-hc'?: string };
+export type FindCottageComplexesData = AxiosResponse<ResultData>;
+export type FindCottageComplexesError = AxiosError<ResultError>;
+export type FindCottageComplexesConfig = {
+  baseURL?: string;
+  params?: FindCottageComplexesParams;
+  headers?: FindCottageComplexesHeaders;
+};
+
+export function findCottageComplexesRequest({
+  baseURL = DEFAULT_BASE_URL,
+  params,
+  headers,
+}: FindCottageComplexesConfig) {
+  return axios
+    .get('/api/v2/cottage-complex', {
+      baseURL,
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'comma', skipNulls: true }),
+      headers: { Accept: 'application/vnd.api+json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (data.errors) return data.errors;
+
+          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 };
+        },
+      ],
+    })
+    .then((res: FindCottageComplexesData) => res)
+    .catch((err: FindCottageComplexesError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/highway/findHighways.ts

@@ -0,0 +1,46 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Highway } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { data: Highway[]; errors: never };
+type ErrorData = {
+  data: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = { ids: string[]; byId: Record<string, Highway> };
+type ResultError = ErrorData['errors'];
+
+export type FindHighwaysData = AxiosResponse<ResultData>;
+export type FindHighwaysError = AxiosError<ResultError>;
+export type FindHighwaysConfig = {
+  baseURL?: string;
+};
+
+export function findHighwaysRequest({ baseURL = DEFAULT_BASE_URL }: FindHighwaysConfig) {
+  return axios
+    .get('/api/v2/highway', {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json' },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (data.errors) return data.errors;
+
+          const ids: ResultData['ids'] = [];
+          const byId: ResultData['byId'] = {};
+
+          data.data.forEach(entity => {
+            byId[entity.id] = entity;
+            ids.push(entity.id);
+          });
+
+          return { ids, byId };
+        },
+      ],
+    })
+    .then((res: FindHighwaysData) => res)
+    .catch((err: FindHighwaysError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/metroStation/findMetroStations.ts

@@ -0,0 +1,46 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { MetroStation } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { data: MetroStation[]; errors: never };
+type ErrorData = {
+  data: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = { ids: string[]; byId: Record<string, MetroStation> };
+type ResultError = ErrorData['errors'];
+
+export type FindMetroStationsData = AxiosResponse<ResultData>;
+export type FindMetroStationsError = AxiosError<ResultError>;
+export type FindMetroStationsConfig = {
+  baseURL?: string;
+};
+
+export function findMetroStationsRequest({ baseURL = DEFAULT_BASE_URL }: FindMetroStationsConfig) {
+  return axios
+    .get('/api/v2/metro-station', {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json' },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (data.errors) return data.errors;
+
+          const ids: ResultData['ids'] = [];
+          const byId: ResultData['byId'] = {};
+
+          data.data.forEach(entity => {
+            byId[entity.id] = entity;
+            ids.push(entity.id);
+          });
+
+          return { ids, byId };
+        },
+      ],
+    })
+    .then((res: FindMetroStationsData) => res)
+    .catch((err: FindMetroStationsError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/realty/createRealty.ts

@@ -0,0 +1,54 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { Realty } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = {
+  data: Realty & {
+    meta: {
+      createdAt?: string;
+      serviceRequestExtId?: number;
+      updatedAt?: string;
+    };
+  };
+  errors: never;
+};
+type ErrorData = {
+  data: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = Realty & { meta: SuccessData['data']['meta'] };
+type ResultError = ErrorData['errors'];
+
+export type CreateRealtyHeaders = { 'x-auth-hc': string };
+export type CreateRealtyBody = {
+  data: {
+    type: Realty['type'];
+    attributes: Pick<Realty['attributes'], 'realtyType' | 'area' | 'roomCount' | 'price' | 'floor'>;
+    relationships: Pick<Realty['relationships'], 'address'>;
+    meta: { serviceRequestExtId: number };
+  };
+};
+export type CreateRealtyData = AxiosResponse<ResultData>;
+export type CreateRealtyError = AxiosError<ResultError>;
+export type CreateRealtyConfig = {
+  baseURL?: string;
+  body: CreateRealtyBody;
+  headers: CreateRealtyHeaders;
+};
+
+export function createRealtyRequest({ baseURL = DEFAULT_BASE_URL, body, headers }: CreateRealtyConfig) {
+  return axios
+    .post('/api/v2/realty', body, {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json', 'Content-Type': 'application/vnd.api+json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.errors ? data.errors : data.data),
+      ],
+    })
+    .then((res: CreateRealtyData) => res)
+    .catch((err: CreateRealtyError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/realty/createRealtyHouseHighwayDistance.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { RealtyHouseHighwayDistance } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { data: RealtyHouseHighwayDistance; errors: never };
+type ErrorData = {
+  data: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['errors'];
+
+export type CreateRealtyHouseHighwayDistanceHeaders = { 'x-auth-hc': string };
+export type CreateRealtyHouseHighwayDistanceBody = { data: Omit<RealtyHouseHighwayDistance, 'id'> };
+export type CreateRealtyHouseHighwayDistanceData = AxiosResponse<ResultData>;
+export type CreateRealtyHouseHighwayDistanceError = AxiosError<ResultError>;
+export type CreateRealtyHouseHighwayDistanceConfig = {
+  baseURL?: string;
+  body: CreateRealtyHouseHighwayDistanceBody;
+  headers: CreateRealtyHouseHighwayDistanceHeaders;
+};
+
+export function createRealtyHouseHighwayDistanceRequest({
+  baseURL = DEFAULT_BASE_URL,
+  body,
+  headers,
+}: CreateRealtyHouseHighwayDistanceConfig) {
+  return axios
+    .post('/api/v2/house-highway-distance', body, {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json', 'Content-Type': 'application/vnd.api+json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.errors ? data.errors : data.data),
+      ],
+    })
+    .then((res: CreateRealtyHouseHighwayDistanceData) => res)
+    .catch((err: CreateRealtyHouseHighwayDistanceError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/realty/createRealtyImage.ts

@@ -0,0 +1,44 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { RealtyImage } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { data: RealtyImage; errors: never };
+type ErrorData = {
+  data: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['errors'];
+
+export type CreateRealtyImageHeaders = { 'x-auth-hc': string };
+export type CreateRealtyImageBody = {
+  data: {
+    type: RealtyImage['type'];
+    attributes: Omit<RealtyImage['attributes'], 'isPinned'>;
+    relationships: RealtyImage['relationships'];
+  };
+};
+export type CreateRealtyImageData = AxiosResponse<ResultData>;
+export type CreateRealtyImageError = AxiosError<ResultError>;
+export type CreateRealtyImageConfig = {
+  baseURL?: string;
+  body: CreateRealtyImageBody;
+  headers: CreateRealtyImageHeaders;
+};
+
+export function createRealtyImageRequest({ baseURL = DEFAULT_BASE_URL, body, headers }: CreateRealtyImageConfig) {
+  return axios
+    .post('/api/v2/realty-image', body, {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json', 'Content-Type': 'application/vnd.api+json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.errors ? data.errors : data.data),
+      ],
+    })
+    .then((res: CreateRealtyImageData) => res)
+    .catch((err: CreateRealtyImageError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/realty/createRealtyMetroDistance.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { RealtyMetroDistance } from '../../types';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = { data: RealtyMetroDistance; errors: never };
+type ErrorData = {
+  data: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['errors'];
+
+export type CreateRealtyMetroDistanceHeaders = { 'x-auth-hc': string };
+export type CreateRealtyMetroDistanceBody = { data: Omit<RealtyMetroDistance, 'id'> };
+export type CreateRealtyMetroDistanceData = AxiosResponse<ResultData>;
+export type CreateRealtyMetroDistanceError = AxiosError<ResultError>;
+export type CreateRealtyMetroDistanceConfig = {
+  baseURL?: string;
+  body: CreateRealtyMetroDistanceBody;
+  headers: CreateRealtyMetroDistanceHeaders;
+};
+
+export function createRealtyMetroDistanceRequest({
+  baseURL = DEFAULT_BASE_URL,
+  body,
+  headers,
+}: CreateRealtyMetroDistanceConfig) {
+  return axios
+    .post('/api/v2/realty-metro-distance', body, {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json', 'Content-Type': 'application/vnd.api+json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.errors ? data.errors : data.data),
+      ],
+    })
+    .then((res: CreateRealtyMetroDistanceData) => res)
+    .catch((err: CreateRealtyMetroDistanceError) => {
+      throw err;
+    });
+}

package/src/clients/v2/api/realty/deleteRealtyImage.ts

@@ -0,0 +1,37 @@
+import axios, { AxiosResponse, AxiosError, AxiosResponseTransformer } from 'axios';
+import { DEFAULT_BASE_URL } from '../../../constants';
+
+type SuccessData = undefined;
+type ErrorData = {
+  data: never;
+  errors: Array<{ source?: { parameter: string }; detail: string; description?: string }>;
+};
+
+type ResultData = null;
+type ResultError = ErrorData['errors'];
+
+export type DeleteRealtyImageHeaders = { 'x-auth-hc': string };
+export type DeleteRealtyImageUrlParams = { id: string };
+export type DeleteRealtyImageData = AxiosResponse<ResultData>;
+export type DeleteRealtyImageError = AxiosError<ResultError>;
+export type DeleteRealtyImageConfig = {
+  baseURL?: string;
+  urlParams: DeleteRealtyImageUrlParams;
+  headers: DeleteRealtyImageHeaders;
+};
+
+export function deleteRealtyImageRequest({ baseURL = DEFAULT_BASE_URL, urlParams, headers }: DeleteRealtyImageConfig) {
+  return axios
+    .delete(`/api/v2/realty-image/${urlParams.id}`, {
+      baseURL,
+      headers: { Accept: 'application/vnd.api+json', 'Content-Type': 'application/vnd.api+json', ...headers },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosResponseTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data?.errors ? data.errors : null),
+      ],
+    })
+    .then((res: DeleteRealtyImageData) => res)
+    .catch((err: DeleteRealtyImageError) => {
+      throw err;
+    });
+}