@nomalism-com/api 0.33.83 → 0.34.2

package/src/modules/document/billOfLading.ts

@@ -0,0 +1,24 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.BillOfLading.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(
+    body: Nomalism.BillOfLading.ICreateRequest,
+  ): Promise<Nomalism.shared.ITaskCluster[]> {
+    const response = await this.api.post(`${this.route}bill_of_lading`, body);
+    return response.data;
+  }
+}

package/src/modules/document/inventario.ts

@@ -0,0 +1,23 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import ICreateInventoryRequest = Nomalism.Inventario.ICreateInventoryRequest;
+
+export default class Repository implements Nomalism.Inventario.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async createInventory(data: ICreateInventoryRequest): Promise<void> {
+    await this.api.post(`${this.route}`, data);
+  }
+}

package/src/modules/document/materialEntrance.ts

@@ -0,0 +1,117 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IUnfinishedPickingLineGroup = Nomalism.MaterialEntrance.IUnfinishedPickingLineGroup;
+export import IUnfinishedPickingsResponse = Nomalism.MaterialEntrance.IUnfinishedPickingsResponse;
+
+export import IPrintLabelParamsRequest = Nomalism.MaterialEntrance.IPrintLabelParamsRequest;
+export import IPrintLabelQueryRequest = Nomalism.MaterialEntrance.IPrintLabelQueryRequest;
+
+export import IPrintBulkLabelRequest = Nomalism.MaterialEntrance.IPrintBulkLabelRequest;
+
+export import IUnfinishedPickingLineGroupExtended = Nomalism.MaterialEntrance.IUnfinishedPickingLineGroupExtended;
+
+export import IGetMaterialEntranceInfoStock = Nomalism.MaterialEntrance.IGetMaterialEntranceInfoStock;
+
+export import IGetMaterialEntranceInfoClientOrder = Nomalism.MaterialEntrance.IGetMaterialEntranceInfoClientOrder;
+
+export import IGetMaterialEntranceInfoResponse = Nomalism.MaterialEntrance.IGetMaterialEntranceInfoResponse;
+
+export import IUndoEntradaDeMaterialRequest = Nomalism.MaterialEntrance.IUndoEntradaDeMaterialRequest;
+
+export import ICreateMaterialEntranceClientOrderOptionEnum = Nomalism.MaterialEntrance.ICreateMaterialEntranceClientOrderOptionEnum;
+
+export import ICreateMaterialEntranceClientOrderOption = Nomalism.MaterialEntrance.ICreateMaterialEntranceClientOrderOption;
+
+export import createMaterialEntranceClientOrderOptions = Nomalism.MaterialEntrance.createMaterialEntranceClientOrderOptions;
+
+export import ICreateMaterialEntranceStockOptionEnum = Nomalism.MaterialEntrance.ICreateMaterialEntranceStockOptionEnum;
+
+export import ICreateMaterialEntranceStockOption = Nomalism.MaterialEntrance.ICreateMaterialEntranceStockOption;
+
+export import createMaterialEntranceStockOptions = Nomalism.MaterialEntrance.createMaterialEntranceStockOptions;
+
+export import ICreateMaterialEntranceStockWithoutOrderOptionEnum = Nomalism.MaterialEntrance.ICreateMaterialEntranceStockWithoutOrderOptionEnum;
+
+export import ICreateMaterialEntranceStockWithoutOrderOption = Nomalism.MaterialEntrance.ICreateMaterialEntranceStockWithoutOrderOption;
+
+export import createMaterialEntranceStockWithoutOrderOptions = Nomalism.MaterialEntrance.createMaterialEntranceStockWithoutOrderOptions;
+
+export import IEntradaDeMaterialClientOrder = Nomalism.MaterialEntrance.IEntradaDeMaterialClientOrder;
+
+export import IEntradaDeMaterialStock = Nomalism.MaterialEntrance.IEntradaDeMaterialStock;
+
+export import IEntradaDeMaterialNC = Nomalism.MaterialEntrance.IEntradaDeMaterialNC;
+
+export import IFinalizarEntradaDeMaterialRequest = Nomalism.MaterialEntrance.IFinalizarEntradaDeMaterialRequest;
+
+export import IFinalizarEntradaDeMaterialResponse = Nomalism.MaterialEntrance.IFinalizarEntradaDeMaterialResponse;
+
+export default class Repository implements Nomalism.MaterialEntrance.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findMaterialEntranceProviders(): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}material_entrance_providers`);
+    return response.data;
+  }
+
+  async findUnfinishedPickings({
+    id,
+  }: Nomalism.shared.IFindByIdRequest): Promise<IUnfinishedPickingsResponse[]> {
+    const response = await this.api.get(`${this.route}unfinished_pickings/${id}`);
+    return response.data;
+  }
+
+  async finalizarEntradaMaterial(
+    data: IFinalizarEntradaDeMaterialRequest,
+  ): Promise<IFinalizarEntradaDeMaterialResponse> {
+    const response = await this.api.post(`${this.route}finalize_material_entrance`, data);
+    return response.data;
+  }
+
+  async undoEntradaMaterial(data: IUndoEntradaDeMaterialRequest): Promise<void> {
+    await this.api.post(`${this.route}undo_material_entrance`, data);
+  }
+
+  printLabelToPdfUrl(
+    { product_id }: IPrintLabelParamsRequest,
+    { quantity, ef_name, pc_document_number, prison, note }: IPrintLabelQueryRequest,
+    token: string,
+  ): string {
+    const qs = new URLSearchParams();
+    qs.set('ef_name', ef_name);
+    qs.set('quantity', quantity.toString());
+    if (pc_document_number) {
+      qs.set('pc_document_number', pc_document_number.toString());
+    }
+    if (note) {
+      qs.set('note', note.toString());
+    }
+    qs.set('prison', prison.toString());
+    qs.set('token', token);
+    return `${this.publicRoute}print_label_pdf/${product_id}?${qs.toString()}`;
+  }
+
+  printBulkLabelToPdfUrl({
+    groupLabel,
+    saved_em_picking_ids,
+    token,
+  }: IPrintBulkLabelRequest): string {
+    const qs = new URLSearchParams();
+    qs.set('groupLabel', groupLabel.toString());
+    qs.set('saved_em_picking_ids', saved_em_picking_ids);
+    qs.set('token', token);
+    return `${this.publicRoute}print_bulk_label_pdf?${qs.toString()}`;
+  }
+}

package/src/modules/document/order.ts

@@ -0,0 +1,88 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IUndoProviderOrderRequest = Nomalism.Order.IUndoProviderOrderRequest;
+
+export import IConferirEncomendaClienteOptions = Nomalism.Order.IConferirEncomendaClienteOptions;
+export import IConferirEncomendaClienteRequest = Nomalism.Order.IConferirEncomendaClienteRequest;
+export import IConferirEncomendaClienteResponse = Nomalism.Order.IConferirEncomendaClienteResponse;
+
+export import IFindStockToOrderResponse = Nomalism.Order.IFindStockToOrderResponse;
+export import IFindStockToOrderRequest = Nomalism.Order.IFindStockToOrderRequest;
+
+export import ISetProviderRequest = Nomalism.Order.ISetProviderRequest;
+
+export import IUnsetCativado = Nomalism.Order.IUnsetCativado;
+
+export import IFindRequest = Nomalism.Order.IFindRequest;
+export import IOrderType = Nomalism.Order.IOrderType;
+export import IFindResponse = Nomalism.Order.IFindResponse;
+
+export const { ConferirEncomendaClienteOptionsEnum, conferirEncomendaClienteOptions } =
+  Nomalism.Order;
+
+export default class Repository implements Nomalism.Order.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async unsetCativado(params: IUnsetCativado): Promise<void> {
+    const response = await this.api.post(`${this.route}unset_cativado`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findStockToOrder(params: IFindStockToOrderRequest): Promise<IFindStockToOrderResponse[]> {
+    const response = await this.api.get(`${this.route}check_lines_to_order`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findProvidersWithStockToOrder(): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}stock_order_provider`);
+    return response.data;
+  }
+
+  async undoEncomendaVA(data: Nomalism.Order.IFindByIdsRequest): Promise<void> {
+    await this.api.post(`${this.route}undo_encomenda_va`, data);
+  }
+
+  async setProvider(data: ISetProviderRequest): Promise<void> {
+    await this.api.post(`${this.route}set_provider`, data);
+  }
+
+  async unsetProvider({ id }: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.post(`${this.route}${id}/unset_provider`);
+  }
+
+  async undoEncomendaStock(data: Nomalism.Order.IFindByIdsRequest): Promise<void> {
+    await this.api.post(`${this.route}undo_encomenda_stock`, data);
+  }
+
+  async undoProviderOrder(data: IUndoProviderOrderRequest): Promise<void> {
+    await this.api.post(`${this.route}undo_provider_order`, data);
+  }
+
+  async conferirEncomendaCliente(
+    data: IConferirEncomendaClienteRequest,
+  ): Promise<IConferirEncomendaClienteResponse[]> {
+    const response = await this.api.post(`${this.route}check_client_order`, data);
+    return response.data;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+}

package/src/modules/document/productionOrder.ts

@@ -0,0 +1,23 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.ProductionOrder.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async createProductionOrder(
+    body: Nomalism.ProductionOrder.ICreateProductionOrderRequest,
+  ): Promise<void> {
+    await this.api.post(`${this.route}production_order`, body);
+  }
+}

package/src/modules/document/proforma.ts

@@ -0,0 +1,22 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.Proforma.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(data: Nomalism.Proforma.ICreateRequest): Promise<Nomalism.shared.ITaskCluster[]> {
+    const result = await this.api.post(`${this.route}pro_forma`, data);
+    return result.data;
+  }
+}

package/src/modules/document/propostaFornecedor.ts

@@ -0,0 +1,24 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.PropostaFornecedor.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async createProviderProposal(
+    data: Nomalism.PropostaFornecedor.IProviderProposalRequest,
+  ): Promise<string> {
+    const result = await this.api.post(`${this.route}provider_proposal`, data);
+    return result.data;
+  }
+}

package/src/modules/document/propostaSheets.ts

@@ -0,0 +1,102 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IConflictEnum = Nomalism.PropostaSheets.IConflictEnum;
+
+export import IConflict = Nomalism.PropostaSheets.IConflict;
+
+export import IFindByGooglesheetIdResponse = Nomalism.PropostaSheets.IFindByGooglesheetIdResponse;
+
+export import IDocumentLinePendingConflict = Nomalism.PropostaSheets.Entity;
+
+export import IConflictFindByOwnerIdResponse = Nomalism.PropostaSheets.IConflictFindByOwnerIdResponse;
+
+export import ICreateSheetFromDocumentResponse = Nomalism.PropostaSheets.ICreateSheetFromDocumentResponse;
+
+export import ICloneSheetToNewDocumentRequest = Nomalism.PropostaSheets.ICloneSheetToNewDocumentRequest;
+export import ICloneSheetToNewDocumentResponse = Nomalism.PropostaSheets.ICloneSheetToNewDocumentResponse;
+
+export import IIsProcessingResponse = Nomalism.PropostaSheets.IIsProcessingResponse;
+
+export import IImportFromSheetRequest = Nomalism.PropostaSheets.IImportFromSheetRequest;
+
+export default class Repository implements Nomalism.PropostaSheets.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async isProcessing(params: Nomalism.shared.IFindByIdRequest): Promise<IIsProcessingResponse> {
+    const response = await this.api.get(`${this.route}is_processing`, {
+      params,
+    });
+
+    return response.data;
+  }
+
+  async importFromSheet(params: IImportFromSheetRequest): Promise<IFindByGooglesheetIdResponse> {
+    const response = await this.api.post(`${this.route}import_from_sheet`, {
+      params,
+    });
+
+    return response.data;
+  }
+
+  async createSheetFromDocument(
+    params: Nomalism.shared.IFindByIdRequest,
+  ): Promise<ICreateSheetFromDocumentResponse> {
+    const response = await this.api.post(`${this.route}create_sheet_from_document`, params);
+
+    return response.data;
+  }
+
+  async cloneSheetsToNewDocument(
+    params: ICloneSheetToNewDocumentRequest,
+  ): Promise<ICloneSheetToNewDocumentResponse> {
+    const response = await this.api.post(`${this.route}clone_sheet_to_new_document`, params);
+
+    return response.data;
+  }
+
+  async conflictAccept(params: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.post(`${this.route}conflict_accept`, params);
+  }
+
+  async conflictDelete(data: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.delete(`${this.route}conflict_delete`, {
+      data,
+    });
+  }
+
+  async conflictFindByOwnerId(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<IConflictFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}conflict_find_by_owner_id`, {
+      params,
+    });
+
+    return response.data;
+  }
+
+  async rmGetDataBySheetId(
+    params: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.PropostaSheets.IRmGetDataBySheetIdResponse> {
+    const response = await this.api.get(`${this.route}rm_data_by_sheet_id/${params.id}`);
+
+    return response.data;
+  }
+  async rmUpdateDataBySheetId(
+    params: Nomalism.shared.IFindByIdRequest,
+    body: Nomalism.PropostaSheets.IRmUpdateDataBySheetIdRequest,
+  ): Promise<void> {
+    await this.api.post(`${this.route}rm_data_by_sheet_id/${params.id}`, body);
+  }
+}

package/src/modules/document/providerCreditNoteFromReturn.ts

@@ -0,0 +1,32 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.ProviderCreditNoteFromReturn.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findProviderReturn(
+    params: Nomalism.ProviderCreditNoteFromReturn.IFindProviderReturnRequest,
+  ): Promise<Nomalism.ProviderCreditNoteFromReturn.IFindProviderReturnResponse[]> {
+    const response = await this.api.get(`${this.route}provider_return`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async createProviderCreditNoteFromReturn(
+    data: Nomalism.ProviderCreditNoteFromReturn.ICreateProviderCreditNoteFromReturnRequest,
+  ): Promise<void> {
+    await this.api.post(`${this.route}provider_credit_note_from_return`, data);
+  }
+}

package/src/modules/document/providerFinancialCreditNote.ts

@@ -0,0 +1,32 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.ProviderFinancialCreditNote.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findProviderInvoice(
+    params: Nomalism.ProviderFinancialCreditNote.IFindProviderInvoiceRequest,
+  ): Promise<Nomalism.ProviderFinancialCreditNote.IFindProviderInvoiceResponse[]> {
+    const response = await this.api.get(`${this.route}provider_invoice`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async createProviderFinancialCreditNote(
+    data: Nomalism.ProviderFinancialCreditNote.ICreateProviderFinancialCreditNoteRequest,
+  ): Promise<void> {
+    await this.api.post(`${this.route}provider_financial_credit_note`, data);
+  }
+}

package/src/modules/document/providerServiceInvoice.ts

@@ -0,0 +1,23 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.ProviderServiceInvoice.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async createProviderServiceInvoice(
+    data: Nomalism.ProviderServiceInvoice.ICreateProviderServiceInvoiceRequest,
+  ): Promise<void> {
+    await this.api.post(`${this.route}provider_service_invoice`, data);
+  }
+}

package/src/modules/document/purchase.ts

@@ -0,0 +1,48 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IUnpaidMaterialEntranceLineType = Nomalism.Purchase.IUnpaidMaterialEntranceLineType;
+
+export import IUnpaidMaterialEntranceLineResponse = Nomalism.Purchase.IUnpaidMaterialEntranceLineResponse;
+
+export import IUnpaidMaterialEntranceItemResponse = Nomalism.Purchase.IUnpaidMaterialEntranceItemResponse;
+export import IPurchaseFromProviderRequest = Nomalism.Purchase.IPurchaseFromProviderRequest;
+export import IUnpaidMaterialEntranceResponse = Nomalism.Purchase.IUnpaidMaterialEntranceResponse;
+
+export default class Repository implements Nomalism.Purchase.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async purchaseFromProvider(data: IPurchaseFromProviderRequest): Promise<void> {
+    await this.api.post(`${this.route}purchase_from_provider`, data);
+  }
+
+  async findUnpaidMaterialEntrance(
+    params: Nomalism.shared.IFindByIdRequest,
+  ): Promise<IUnpaidMaterialEntranceResponse> {
+    const response = await this.api.get(`${this.route}unpaid_material_entrance`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findUnpaidMaterialEntranceProviders(): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}unpaid_material_entrance_providers`);
+    return response.data;
+  }
+
+  async sync(data: Nomalism.Purchase.ISyncRequest): Promise<Nomalism.Purchase.ISyncResponse> {
+    const response = await this.api.post(`${this.route}sync`, data);
+    return response.data;
+  }
+}

package/src/modules/document/quebra.ts

@@ -0,0 +1,47 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IInventoryLossResponse = Nomalism.Quebra.IInventoryLossResponse;
+
+export import ICreateManyRequest = Nomalism.Quebra.ICreateManyRequest;
+
+export import IDeleteInventoryLossRequest = Nomalism.Quebra.IDeleteInventoryLossRequest;
+
+export default class Repository implements Nomalism.Quebra.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findInventoryLosses(): Promise<IInventoryLossResponse[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findInventoryLossesProviders(): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}providers`);
+    return response.data;
+  }
+
+  async create(body: ICreateManyRequest): Promise<string> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async createMany(body: ICreateManyRequest): Promise<string> {
+    const response = await this.api.post(`${this.route}create_many`, body);
+    return response.data;
+  }
+
+  async deleteInventoryLosses(data: IDeleteInventoryLossRequest): Promise<void> {
+    await this.api.delete(`${this.route}inventory_loss`, { data });
+  }
+}

package/src/modules/document/returnToProvider.ts

@@ -0,0 +1,43 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindOptionalByOwnerIdRequest = Nomalism.shared.IFindOptionalByOwnerIdRequest;
+export import IFindLinesToReturnResponse = Nomalism.ReturnToProvider.IFindLinesToReturnResponse;
+
+export import ICheckLinesToReturnOptions = Nomalism.ReturnToProvider.ICheckLinesToReturnOptions;
+
+export import ICheckLinesToReturnLinesRequest = Nomalism.ReturnToProvider.ICheckLinesToReturnLinesRequest;
+export import ICheckLinesToReturnRequest = Nomalism.ReturnToProvider.ICheckLinesToReturnRequest;
+
+export default class Repository implements Nomalism.ReturnToProvider.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findLinesToReturn(
+    params: IFindOptionalByOwnerIdRequest,
+  ): Promise<IFindLinesToReturnResponse[]> {
+    const response = await this.api.get(`${this.route}lines_to_return`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findLinesToReturnProviders(): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}lines_to_return_providers`);
+    return response.data;
+  }
+
+  async checkLinesToReturn(data: ICheckLinesToReturnRequest): Promise<void> {
+    await this.api.post(`${this.route}check_to_return`, data);
+  }
+}

package/src/modules/document/transformado.ts

@@ -0,0 +1,26 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import ICreateTransformado = Nomalism.Transformado.ICreateTransformado;
+
+export import IProductsCreateTransformado = Nomalism.Transformado.IProductsCreateTransformado;
+
+export default class Repository implements Nomalism.Transformado.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(body: ICreateTransformado): Promise<string> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+}