@nomalism-com/api 0.34.1 → 0.34.3

package/src/modules/supply/documentLineAssoc.ts

@@ -2,18 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IEntity = Nomalism.DocumentLineAssoc.Entity;
-
-export import IEntityWithDocumentLine = Nomalism.DocumentLineAssoc.IEntityWithDocumentLine;
-
-export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
-export import IEntityExtended = Nomalism.DocumentLineAssoc.IEntityExtended;
-
-export import ICreateRequest = Nomalism.DocumentLineAssoc.ICreateRequest;
-
-export import IUpdateRequest = Nomalism.DocumentLineAssoc.IUpdateRequest;
-export import IFindByIdRequest = Nomalism.shared.IFindByIdRequest;
-
 export default class Repository implements Nomalism.DocumentLineAssoc.IApi {
   public route: string;
 
@@ -27,13 +15,15 @@ export default class Repository implements Nomalism.DocumentLineAssoc.IApi {
     this.publicRoute = publicRoute;
   }
 
-  async findByOwnerId(params?: IFindByOwnerIdRequest): Promise<IEntityExtended[]> {
+  async findByOwnerId(
+    params?: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<Nomalism.DocumentLineAssoc.IEntityExtended[]> {
     const response = await this.api.get(`${this.route}by_owner`, { params });
     return response.data;
   }
 
   async findVirtualsByOwnerId(
-    params?: IFindByOwnerIdRequest,
+    params?: Nomalism.shared.IFindByOwnerIdRequest,
   ): Promise<Nomalism.DocumentLine.IDocumentLineVirtuals[]> {
     const response = await this.api.get(`${this.route}virtuals_by_owner`, {
       params,
@@ -41,22 +31,26 @@ export default class Repository implements Nomalism.DocumentLineAssoc.IApi {
     return response.data;
   }
 
-  async findHistoryByLineId(params: IFindByIdRequest): Promise<Nomalism.DocumentLine.IHistory[]> {
+  async findHistoryByLineId(
+    params: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.DocumentLine.IHistory[]> {
     const response = await this.api.get(`${this.route}history_by_line_id`, {
       params,
     });
     return response.data;
   }
 
-  async create(body: ICreateRequest[]): Promise<IEntityWithDocumentLine[]> {
+  async create(
+    body: Nomalism.DocumentLineAssoc.ICreateRequest[],
+  ): Promise<Nomalism.DocumentLineAssoc.IEntityWithDocumentLine[]> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IEntityWithDocumentLine> {
+    body: Nomalism.DocumentLineAssoc.IUpdateRequest,
+  ): Promise<Nomalism.DocumentLineAssoc.IEntityWithDocumentLine> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }

package/src/modules/supply/documentLineNote.ts

@@ -2,11 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import ICreateRequest = Nomalism.DocumentLineNote.ICreateRequest;
-
-export import IUpdateRequest = Nomalism.DocumentLineNote.IUpdateRequest;
-export import IEntity = Nomalism.DocumentLineNote.Entity;
-
 export default class Repository implements Nomalism.DocumentLineNote.IRepository {
   public route: string;
 
@@ -20,12 +15,15 @@ export default class Repository implements Nomalism.DocumentLineNote.IRepository
     this.publicRoute = publicRoute;
   }
 
-  async create(body: ICreateRequest): Promise<string> {
+  async create(body: Nomalism.DocumentLineNote.ICreateRequest): Promise<string> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
-  async update(selector: Nomalism.shared.IFindByIdRequest, body: IUpdateRequest): Promise<void> {
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: Nomalism.DocumentLineNote.IUpdateRequest,
+  ): Promise<void> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }

package/src/modules/supply/documentSet.ts

@@ -2,15 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IEntity = Nomalism.DocumentSet.Entity;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
-export import ICreateRequest = Nomalism.DocumentSet.ICreateRequest;
-
-export import IUpdateRequest = Nomalism.DocumentSet.IUpdateRequest;
-
 export default class Repository implements Nomalism.DocumentSet.IRepository {
   public route: string;
 
@@ -24,35 +15,41 @@ export default class Repository implements Nomalism.DocumentSet.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async find(): Promise<IEntity[]> {
+  async find(): Promise<Nomalism.DocumentSet.Entity[]> {
     const response = await this.api.get(`${this.route}`);
     return response.data;
   }
 
-  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.DocumentSet.Entity | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, { params });
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(body: Nomalism.DocumentSet.ICreateRequest): Promise<Nomalism.DocumentSet.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IEntity | null> {
+    body: Nomalism.DocumentSet.IUpdateRequest,
+  ): Promise<Nomalism.DocumentSet.Entity | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.DocumentSet.Entity | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/supply/documentType.ts

@@ -2,28 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IDocumentTypeUserType = Nomalism.DocumentType.IDocumentTypeUserType;
-
-export import IDocumentTypeCodeType = Nomalism.DocumentType.IDocumentTypeCodeType;
-
-export import DocumentTypeUserTypeEnum = Nomalism.DocumentType.DocumentTypeUserTypeEnum;
-
-export import documentTypeUserTypes = Nomalism.DocumentType.documentTypeUserTypes;
-
-export import IFindRequest = Nomalism.DocumentType.IFindRequest;
-export import IFindResponse = Nomalism.DocumentType.IFindResponse;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
-export import IEntityExtended = Nomalism.DocumentType.IEntityExtended;
-
-export import ICreateRequest = Nomalism.DocumentType.ICreateRequest;
-
-export import IEntity = Nomalism.DocumentType.Entity;
-
-export import IUpdateRequest = Nomalism.DocumentType.IUpdateRequest;
-
 export default class Repository implements Nomalism.DocumentType.IApi {
   public route: string;
 
@@ -37,37 +15,45 @@ export default class Repository implements Nomalism.DocumentType.IApi {
     this.publicRoute = publicRoute;
   }
 
-  async find(params?: IFindRequest): Promise<IFindResponse[]> {
+  async find(
+    params?: Nomalism.DocumentType.IFindRequest,
+  ): Promise<Nomalism.DocumentType.IFindResponse[]> {
     const response = await this.api.get(`${this.route}`, { params });
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, { params });
     return response.data;
   }
 
-  async findDetailed(params?: IFindRequest): Promise<IEntityExtended[]> {
+  async findDetailed(
+    params?: Nomalism.DocumentType.IFindRequest,
+  ): Promise<Nomalism.DocumentType.IEntityExtended[]> {
     const response = await this.api.get(`${this.route}detailed`, { params });
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntityExtended> {
+  async create(
+    body: Nomalism.DocumentType.ICreateRequest,
+  ): Promise<Nomalism.DocumentType.IEntityExtended> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdNumberRequest,
-    body: IUpdateRequest,
-  ): Promise<IEntityExtended | null> {
+    body: Nomalism.DocumentType.IUpdateRequest,
+  ): Promise<Nomalism.DocumentType.IEntityExtended | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
   async deleteOne(
     selector: Nomalism.shared.IFindByIdNumberRequest,
-  ): Promise<IEntityExtended | null> {
+  ): Promise<Nomalism.DocumentType.IEntityExtended | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/supply/externalDocumentHeader.ts

@@ -2,24 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IEntity = Nomalism.ExternalDocumentHeader.Entity;
-
-export import ICreateRequest = Nomalism.ExternalDocumentHeader.ICreateRequest;
-export import IUpdateRequest = Nomalism.ExternalDocumentHeader.IUpdateRequest;
-
-export import IFindRequest = Nomalism.ExternalDocumentHeader.IFindRequest;
-export import IFindResponse = Nomalism.ExternalDocumentHeader.IFindResponse;
-
-export import IFindPaginatedRequest = Nomalism.ExternalDocumentHeader.IFindPaginatedRequest;
-export import IFindWithPaginationResponse = Nomalism.ExternalDocumentHeader.IFindWithPaginationResponse;
-
-export import IFindByIdRequest = Nomalism.shared.IFindByIdRequest;
-export import IFindByIdResponse = Nomalism.ExternalDocumentHeader.IFindByIdResponse;
-
-export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
-
-export import ISendEmailDocumentRequest = Nomalism.ExternalDocumentHeader.ISendEmailDocumentRequest;
-
 export default class Repository implements Nomalism.ExternalDocumentHeader.IRepository {
   public route: string;
 
@@ -33,23 +15,30 @@ export default class Repository implements Nomalism.ExternalDocumentHeader.IRepo
     this.publicRoute = publicRoute;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(
+    body: Nomalism.ExternalDocumentHeader.ICreateRequest,
+  ): Promise<Nomalism.ExternalDocumentHeader.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
-  async update(selector: IFindByIdRequest, body: IUpdateRequest): Promise<IEntity | null> {
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: Nomalism.ExternalDocumentHeader.IUpdateRequest,
+  ): Promise<Nomalism.ExternalDocumentHeader.Entity | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
-  async findById(selector: IFindByIdRequest): Promise<IFindByIdResponse | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.ExternalDocumentHeader.IFindByIdResponse | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
   async findByOwnerId(
-    params?: IFindByOwnerIdRequest,
+    params?: Nomalism.shared.IFindByOwnerIdRequest,
   ): Promise<Nomalism.ExternalDocumentHeader.IFindByOwnerIdItemWithVersions[]> {
     const response = await this.api.get(`${this.route}by_owner`, { params });
     return response.data;
@@ -64,22 +53,30 @@ export default class Repository implements Nomalism.ExternalDocumentHeader.IRepo
     return response.data;
   }
 
-  async find(params?: IFindRequest): Promise<IFindResponse[]> {
+  async find(
+    params?: Nomalism.ExternalDocumentHeader.IFindRequest,
+  ): Promise<Nomalism.ExternalDocumentHeader.IFindResponse[]> {
     const response = await this.api.get(`${this.route}`, { params });
     return response.data;
   }
 
-  async findPaginated(params: IFindPaginatedRequest): Promise<IFindWithPaginationResponse> {
+  async findPaginated(
+    params: Nomalism.ExternalDocumentHeader.IFindPaginatedRequest,
+  ): Promise<Nomalism.ExternalDocumentHeader.IFindWithPaginationResponse> {
     const response = await this.api.get(`${this.route}paginated`, { params });
     return response.data;
   }
 
-  async deleteOne(params?: IFindByIdRequest): Promise<IEntity | null> {
+  async deleteOne(
+    params?: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.ExternalDocumentHeader.Entity | null> {
     const response = await this.api.get(`${this.route}`, { params });
     return response.data;
   }
 
-  async sendEmailDocument(body: ISendEmailDocumentRequest): Promise<void> {
+  async sendEmailDocument(
+    body: Nomalism.ExternalDocumentHeader.ISendEmailDocumentRequest,
+  ): Promise<void> {
     await this.api.post(`${this.route}sendEmail`, body);
   }
 

package/src/modules/supply/externalDocumentType.ts

@@ -2,11 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IEntity = Nomalism.ExternalDocumentType.Entity;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
 export default class Repository implements Nomalism.ExternalDocumentType.IRepository {
   public route: string;
 
@@ -20,12 +15,14 @@ export default class Repository implements Nomalism.ExternalDocumentType.IReposi
     this.publicRoute = publicRoute;
   }
 
-  async find(): Promise<IEntity[]> {
+  async find(): Promise<Nomalism.ExternalDocumentType.Entity[]> {
     const response = await this.api.get(`${this.route}`);
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, { params });
     return response.data;
   }

package/src/modules/supply/orderManagement.ts

@@ -2,10 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindProviderProductsRequest = Nomalism.OrderManagement.IFindProviderProductsRequest;
-export import IFindProviderProductsResponse = Nomalism.OrderManagement.IFindProviderProductsResponse;
-export import IFindAllProviderProductsResponse = Nomalism.OrderManagement.IFindAllProviderProductsResponse;
-
 export default class Repository implements Nomalism.OrderManagement.IRepository {
   public route: string;
 
@@ -20,15 +16,17 @@ export default class Repository implements Nomalism.OrderManagement.IRepository
   }
 
   async findProviderProducts(
-    params: IFindProviderProductsRequest,
-  ): Promise<IFindProviderProductsResponse[]> {
+    params: Nomalism.OrderManagement.IFindProviderProductsRequest,
+  ): Promise<Nomalism.OrderManagement.IFindProviderProductsResponse[]> {
     const response = await this.api.get(`${this.route}provider_products`, {
       params,
     });
     return response.data;
   }
 
-  async findAllProviderProducts(): Promise<IFindAllProviderProductsResponse[]> {
+  async findAllProviderProducts(): Promise<
+    Nomalism.OrderManagement.IFindAllProviderProductsResponse[]
+  > {
     const response = await this.api.get(`${this.route}all_provider_products`);
     return response.data;
   }

package/src/modules/supply/payment.ts

@@ -2,42 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindRequest = Nomalism.Payment.IFindRequest;
-export import IFindResponse = Nomalism.Payment.IFindResponse;
-
-export import IFindPaginatedRequest = Nomalism.Payment.IFindPaginatedRequest;
-
-export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
-export import IFindByIdRequest = Nomalism.shared.IFindByIdRequest;
-
-export import ICurrentAccountNotes = Nomalism.Payment.ICurrentAccountNotes;
-export import IFindCurrentAccountByOwnerIdResponse = Nomalism.Payment.IFindCurrentAccountByOwnerIdResponse;
-
-export import ICreateForThisDocumentHeaderRequest = Nomalism.Payment.ICreateForThisDocumentHeaderRequest;
-
-export import ICreateRequest = Nomalism.Payment.ICreateRequest;
-
-export import IEntity = Nomalism.Payment.Entity;
-
-export import IExportPaymentsRequest = Nomalism.Payment.IExportPaymentsRequest;
-export import IPaymentsBatchResponse = Nomalism.Payment.IPaymentsBatchResponse;
-
-export import IUnpaidPurchasesRequest = Nomalism.Payment.IUnpaidPurchasesRequest;
-export import IUnpaidPurchasesResponse = Nomalism.Payment.IUnpaidPurchasesResponse;
-export import IUnpaidByDatePurchasesRequest = Nomalism.Payment.IUnpaidByDatePurchasesRequest;
-export import IFindProvidersWithClientIdResponse = Nomalism.Payment.IFindProvidersWithClientIdResponse;
-
-export import IProviderPaymentDocument = Nomalism.Payment.IProviderPaymentDocument;
-export import IProviderPaymentRequest = Nomalism.Payment.IProviderPaymentRequest;
-
-export import IPaymentsNotExportedRequest = Nomalism.Payment.IPaymentsNotExportedRequest;
-export import IPaymentsNotExportedResponse = Nomalism.Payment.IPaymentsNotExportedResponse;
-
-export import IExportCurrentAccountRequest = Nomalism.Payment.IExportCurrentAccountRequest;
-
-export type IPaginationResponse =
-  Nomalism.shared.IPaginationResponse<Nomalism.Payment.IFindResponse>;
-
 export default class Repository implements Nomalism.Payment.IRepository {
   public route: string;
 
@@ -51,36 +15,42 @@ export default class Repository implements Nomalism.Payment.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async find(params: IFindRequest): Promise<IFindResponse[]> {
+  async find(params: Nomalism.Payment.IFindRequest): Promise<Nomalism.Payment.IFindResponse[]> {
     const response = await this.api.get(`${this.route}`, { params });
     return response.data;
   }
 
-  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+  async findPaginated(
+    params: Nomalism.Payment.IFindPaginatedRequest,
+  ): Promise<Nomalism.shared.IPaginationResponse<Nomalism.Payment.IFindResponse>> {
     const response = await this.api.get(`${this.route}paginated`, { params });
     return response.data;
   }
 
-  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindResponse[]> {
+  async findByOwnerId(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<Nomalism.Payment.IFindResponse[]> {
     const response = await this.api.get(`${this.route}by_owner`, {
       params,
     });
     return response.data;
   }
 
-  async findById(selector: IFindByIdRequest): Promise<IEntity | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.Payment.Entity | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async deleteBatch(selector: IFindByIdRequest): Promise<void> {
+  async deleteBatch(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
     const response = await this.api.delete(`${this.route}delete_batch${selector.id}`);
     return response.data;
   }
 
   async findCurrentAccountByOwnerId(
     params: Nomalism.shared.IFindByOwnerIdRequest,
-  ): Promise<IFindCurrentAccountByOwnerIdResponse[]> {
+  ): Promise<Nomalism.Payment.IFindCurrentAccountByOwnerIdResponse[]> {
     const response = await this.api.get(`${this.route}current_account`, {
       params,
     });
@@ -95,34 +65,38 @@ export default class Repository implements Nomalism.Payment.IRepository {
   }
 
   async findSettledMaterialEntrance(
-    params: IUnpaidPurchasesRequest,
-  ): Promise<IUnpaidPurchasesResponse[]> {
+    params: Nomalism.Payment.IUnpaidPurchasesRequest,
+  ): Promise<Nomalism.Payment.IUnpaidPurchasesResponse[]> {
     const response = await this.api.get(`${this.route}settled_material_entrance`, {
       params,
     });
     return response.data;
   }
 
-  async findSettledMaterialEntranceProviders(): Promise<IFindProvidersWithClientIdResponse[]> {
+  async findSettledMaterialEntranceProviders(): Promise<
+    Nomalism.Users.IFindProvidersWithClientIdResponse[]
+  > {
     const response = await this.api.get(`${this.route}settled_material_entrance_providers`);
     return response.data;
   }
 
-  async createProvidersPayments(body: IProviderPaymentRequest[]): Promise<string[]> {
+  async createProvidersPayments(
+    body: Nomalism.Payment.IProviderPaymentRequest[],
+  ): Promise<string[]> {
     const response = await this.api.post(`${this.route}provider`, body);
     return response.data;
   }
 
   async findPaymentsNotExported(
-    params: IPaymentsNotExportedRequest,
-  ): Promise<IPaymentsNotExportedResponse[]> {
+    params: Nomalism.Payment.IPaymentsNotExportedRequest,
+  ): Promise<Nomalism.Payment.IPaymentsNotExportedResponse[]> {
     const response = await this.api.get(`${this.route}not_exported`, {
       params,
     });
     return response.data;
   }
 
-  async findPaymentBatches(): Promise<IPaymentsBatchResponse[]> {
+  async findPaymentBatches(): Promise<Nomalism.Payment.IPaymentsBatchResponse[]> {
     const response = await this.api.get(`${this.route}batches`);
     return response.data;
   }
@@ -132,8 +106,8 @@ export default class Repository implements Nomalism.Payment.IRepository {
   }
 
   async exportCurrentAccount(
-    params: IExportCurrentAccountRequest,
-  ): Promise<IFindCurrentAccountByOwnerIdResponse[]> {
+    params: Nomalism.Payment.IExportCurrentAccountRequest,
+  ): Promise<Nomalism.Payment.IFindCurrentAccountByOwnerIdResponse[]> {
     const response = await this.api.get(`${this.publicRoute}export_current_account`, {
       params,
     });
@@ -141,15 +115,15 @@ export default class Repository implements Nomalism.Payment.IRepository {
   }
 
   async findSettledMaterialEntranceByDate(
-    params: IUnpaidByDatePurchasesRequest,
-  ): Promise<IUnpaidPurchasesResponse[]> {
+    params: Nomalism.Payment.IUnpaidByDatePurchasesRequest,
+  ): Promise<Nomalism.Payment.IUnpaidPurchasesResponse[]> {
     const response = await this.api.get(`${this.route}settled_material_entrance_by_date`, {
       params,
     });
     return response.data;
   }
 
-  async exportPayments(body: IExportPaymentsRequest[]): Promise<void> {
+  async exportPayments(body: Nomalism.Payment.IExportPaymentsRequest[]): Promise<void> {
     await this.api.post(`${this.route}export_payments`, body);
   }
 
@@ -159,7 +133,7 @@ export default class Repository implements Nomalism.Payment.IRepository {
     end_date,
     output,
     token,
-  }: IExportCurrentAccountRequest): string {
+  }: Nomalism.Payment.IExportCurrentAccountRequest): string {
     const qs = new URLSearchParams();
     qs.set('owner_id', owner_id);
     qs.set('output', output);

package/src/modules/supply/preSale.ts

@@ -2,26 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindResponse = Nomalism.PreSale.IFindResponse;
-export import IFindResponseWithCount = Nomalism.PreSale.IFindResponseWithCount;
-
-export import ICreateRequest = Nomalism.PreSale.ICreateRequest;
-
-export import IProductMinified = Nomalism.PreSale.IPreSaleProduct;
-export import IEntityExtended = Nomalism.PreSale.IEntityExtended;
-
-export import IUpdateRequest = Nomalism.PreSale.IUpdateRequest;
-export import IUpdatePreSaleQuantityRequest = Nomalism.PreSale.IUpdatePreSaleQuantityRequest;
-
-export import IRemovePreSaleProductRequest = Nomalism.PreSale.IRemovePreSaleProductRequest;
-
-export import IImportToClientProposalRequest = Nomalism.PreSale.IImportToClientProposalRequest;
-
-export import IPreSaleFindByUser = Nomalism.PreSale.IPreSaleFindByUser;
-
-export type IPaginationResponse =
-  Nomalism.shared.IPaginationResponse<Nomalism.PreSale.IFindResponse>;
-
 export default class Repository implements Nomalism.PreSale.IRepository {
   public route: string;
 
@@ -35,51 +15,57 @@ export default class Repository implements Nomalism.PreSale.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async find(selector: Nomalism.PreSale.IPreSaleFindByUser): Promise<IFindResponseWithCount[]> {
+  async find(
+    selector: Nomalism.PreSale.IPreSaleFindByUser,
+  ): Promise<Nomalism.PreSale.IFindResponseWithCount[]> {
     const response = await this.api.get(`${this.route}by_user/${selector.created_by}`);
     return response.data;
   }
 
-  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntityExtended | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.PreSale.IEntityExtended | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async findPending(): Promise<IEntityExtended[]> {
+  async findPending(): Promise<Nomalism.PreSale.IEntityExtended[]> {
     const response = await this.api.get(`${this.route}pending`);
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IFindResponse> {
+  async create(body: Nomalism.PreSale.ICreateRequest): Promise<Nomalism.PreSale.IFindResponse> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IFindResponse | null> {
+    body: Nomalism.PreSale.IUpdateRequest,
+  ): Promise<Nomalism.PreSale.IFindResponse | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
   async updatePreSaleQuantity(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdatePreSaleQuantityRequest,
-  ): Promise<IFindResponse | null> {
+    body: Nomalism.PreSale.IUpdatePreSaleQuantityRequest,
+  ): Promise<Nomalism.PreSale.IFindResponse | null> {
     const response = await this.api.put(`${this.route}${selector.id}/quantity`, body);
     return response.data;
   }
 
   async removeProduct(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IRemovePreSaleProductRequest,
+    body: Nomalism.PreSale.IRemovePreSaleProductRequest,
   ): Promise<void> {
     const response = await this.api.put(`${this.route}product/${selector.id}`, body);
     return response.data;
   }
 
-  async importToClientProposal(data: IImportToClientProposalRequest): Promise<void> {
+  async importToClientProposal(
+    data: Nomalism.PreSale.IImportToClientProposalRequest,
+  ): Promise<void> {
     const response = await this.api.post(`${this.route}client_proposal`, data);
     return response.data;
   }