@nomalism-com/api 0.33.83 → 0.34.2

package/src/modules/stock/typeOfLocation.ts

@@ -0,0 +1,81 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.TypeOfLocation.IFindRequest;
+export import IFindResponse = Nomalism.TypeOfLocation.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.TypeOfLocation.IFindPaginatedRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+
+export import ICreateRequest = Nomalism.TypeOfLocation.ICreateRequest;
+export import IEntity = Nomalism.TypeOfLocation.Entity;
+
+export import IUpdateRequest = Nomalism.TypeOfLocation.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.TypeOfLocation.IFindResponse>;
+
+export default class Repository implements Nomalism.TypeOfLocation.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 find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/stock/unitOfMeasure.ts

@@ -0,0 +1,81 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.UnitOfMeasure.IFindRequest;
+export import IFindResponse = Nomalism.UnitOfMeasure.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.UnitOfMeasure.IFindPaginatedRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+
+export import ICreateRequest = Nomalism.UnitOfMeasure.ICreateRequest;
+export import IEntity = Nomalism.UnitOfMeasure.Entity;
+
+export import IUpdateRequest = Nomalism.UnitOfMeasure.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.UnitOfMeasure.IFindResponse>;
+
+export default class Repository implements Nomalism.UnitOfMeasure.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 find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/stock/vatTax.ts

@@ -0,0 +1,81 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.VatTax.IFindRequest;
+export import IFindResponse = Nomalism.VatTax.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.VatTax.IFindPaginatedRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+
+export import ICreateRequest = Nomalism.VatTax.ICreateRequest;
+export import IEntity = Nomalism.VatTax.Entity;
+
+export import IUpdateRequest = Nomalism.VatTax.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.VatTax.IFindResponse>;
+
+export default class Repository implements Nomalism.VatTax.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 find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/stock/vatTaxZone.ts

@@ -0,0 +1,83 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.VatTaxZone.IFindRequest;
+export import IFindResponse = Nomalism.VatTaxZone.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.VatTaxZone.IFindPaginatedRequest;
+export import IFindByOwnerIdResponse = Nomalism.VatTaxZone.IFindByOwnerIdResponse;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+
+export import ICreateRequest = Nomalism.VatTaxZone.ICreateRequest;
+
+export import IEntity = Nomalism.VatTaxZone.Entity;
+
+export import IUpdateRequest = Nomalism.VatTaxZone.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.VatTaxZone.IFindResponse>;
+
+export default class Repository implements Nomalism.VatTaxZone.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 find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IFindResponse | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/supply/clientCurrentAccount.ts

@@ -0,0 +1,83 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.ClientCurrentAccount.Entity;
+
+export import IFindRequest = Nomalism.ClientCurrentAccount.IFindRequest;
+
+export import IFindFaturasPorPagarResponse = Nomalism.ClientCurrentAccount.IFindFaturasPorPagarResponse;
+export import IPagarFaturaRequest = Nomalism.ClientCurrentAccount.IPagarFaturaRequest;
+
+export import IFindFaturasParaDevolucaoResponse = Nomalism.ClientCurrentAccount.IFindFaturasParaDevolucaoResponse;
+
+export import ILinhasFaturasParaDevolucao = Nomalism.ClientCurrentAccount.ILinhasFaturasParaDevolucao;
+
+export import IDevolverRequest = Nomalism.ClientCurrentAccount.IDevolverRequest;
+
+export import IBasicSearchRequest = Nomalism.ClientCurrentAccount.IBasicSearchRequest;
+export import IBasicSearchResponse = Nomalism.ClientCurrentAccount.IBasicSearchResponse;
+
+export import IMultipleRegularizations = Nomalism.ClientCurrentAccount.IMultipleRegularizations;
+
+export default class Repository implements Nomalism.ClientCurrentAccount.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 findByOwnerId(params: IFindRequest): Promise<Nomalism.shared.IPaginationResponse<IEntity>> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findFaturaPorPagar(
+    params: Nomalism.shared.IFindByIdRequest,
+  ): Promise<IFindFaturasPorPagarResponse> {
+    const response = await this.api.get(`${this.route}fatura_por_pagar`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async pagarFatura(data: IPagarFaturaRequest): Promise<void> {
+    await this.api.post(`${this.route}pagar_fatura`, data);
+  }
+
+  async findFaturaParaDevolver(
+    params: Nomalism.shared.IFindByIdRequest,
+  ): Promise<IFindFaturasParaDevolucaoResponse> {
+    const response = await this.api.get(`${this.route}fatura_para_devolver`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async devolver(data: IDevolverRequest): Promise<void> {
+    await this.api.post(`${this.route}devolver`, data);
+  }
+
+  async findByBasicSearch(
+    params: IBasicSearchRequest,
+  ): Promise<Nomalism.shared.IPaginationResponse<IBasicSearchResponse>> {
+    const response = await this.api.get(`${this.route}basic_search`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async regularizarMultiplosDocumentos(data: IMultipleRegularizations): Promise<void> {
+    await this.api.post(`${this.route}multiple_documents`, {
+      data,
+    });
+  }
+}

package/src/modules/supply/documentHeader.ts

@@ -0,0 +1,221 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance, type AxiosResponse } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindOneResponse = Nomalism.DocumentHeader.IFindOneResponse;
+
+export import IFindRequest = Nomalism.DocumentHeader.IFindRequest;
+
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import IBasicSearchRequest = Nomalism.DocumentHeader.IBasicSearchRequest;
+
+export import IBasicSearchResponse = Nomalism.DocumentHeader.IBasicSearchResponse;
+
+export import ICreateRequest = Nomalism.DocumentHeader.ICreateRequest;
+export import ICreateResponse = Nomalism.DocumentHeader.ICreateResponse;
+
+export import IUpdateRequest = Nomalism.DocumentHeader.IUpdateRequest;
+
+export import IEntity = Nomalism.DocumentHeader.Entity;
+
+export import IStartDocumentHeaderVirtuals = Nomalism.DocumentHeader.IStartDocumentHeaderVirtuals;
+
+export import IDocumentHeaderClientVirtuals = Nomalism.DocumentHeader.IDocumentHeaderClientVirtuals;
+
+export import IDocumentHeaderProviderVirtuals = Nomalism.DocumentHeader.IDocumentHeaderProviderVirtuals;
+
+export import ICreateFromHeaderMaturityDate = Nomalism.DocumentHeader.ICreateFromHeaderMaturityDate;
+
+export import ICreateFromHeaderRequest = Nomalism.DocumentHeader.ICreateFromHeaderRequest;
+
+export import IGetActionsResponse = Nomalism.DocumentHeader.IGetActionsResponse;
+
+export import ITaskCluster = Nomalism.shared.ITaskCluster;
+
+export import IUnpaidDocumentResponse = Nomalism.DocumentHeader.IUnpaidDocumentResponse;
+
+export import ITransferOwnershipRequest = Nomalism.DocumentHeader.ITransferOwnershipRequest;
+
+export import IUpdateManyWithPersona = Nomalism.DocumentHeader.IUpdateManyWithPersona;
+
+export import IFindResponse = Nomalism.DocumentHeader.IFindResponse;
+
+export import ISendClientNotificationRequest = Nomalism.DocumentHeader.ISendClientNotificationRequest;
+
+export import IDocumentPdfRequest = Nomalism.DocumentHeader.IDocumentPdfRequest;
+
+export import IFindByTypeRequest = Nomalism.DocumentHeader.IFindByTypeRequest;
+export import IFindByTypeResponse = Nomalism.DocumentHeader.IFindByTypeResponse;
+
+export import IDocumentListResponse = Nomalism.DocumentHeader.IDocumentListResponse;
+
+export default class Repository implements Nomalism.DocumentHeader.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 findOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindOneResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async findStart(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindOneResponse | null> {
+    const response = await this.api.get(`${this.route}start/${selector.id}`);
+    return response.data;
+  }
+
+  async findStartVirtual(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<IStartDocumentHeaderVirtuals | null> {
+    const response = await this.api.get(`${this.route}start_virtual/${selector.id}`);
+    return response.data;
+  }
+
+  async findByBasicSearch(
+    params: IBasicSearchRequest,
+  ): Promise<Nomalism.shared.IPaginationResponse<IBasicSearchResponse>> {
+    const response = await this.api.get(`${this.route}basic_search`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByType(params: IFindByTypeRequest): Promise<IFindByTypeResponse[]> {
+    const response = await this.api.get(`${this.route}by_type`, { params });
+    return response.data;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findClientUnpaidCredit(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<IUnpaidDocumentResponse[]> {
+    const response = await this.api.get(`${this.route}unpaid_credit`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findClientUnpaidDebit(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<IUnpaidDocumentResponse[]> {
+    const response = await this.api.get(`${this.route}unpaid_debit`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findUnpaidCommissions(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<IUnpaidDocumentResponse[]> {
+    const response = await this.api.get(`${this.route}unpaid_commissions`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<ICreateResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async createFromHeader(body: ICreateFromHeaderRequest): Promise<ITaskCluster[]> {
+    const response = await this.api.post(`${this.route}from_header`, body);
+    return response.data;
+  }
+
+  async update(selector: Nomalism.shared.IFindByIdRequest, body: IUpdateRequest): Promise<void> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.delete(`${this.route}${selector.id}`);
+  }
+
+  async getActions(selector: Nomalism.shared.IFindByIdRequest): Promise<IGetActionsResponse[]> {
+    const response = await this.api.get(`${this.route}get_actions/${selector.id}`);
+    return response.data;
+  }
+
+  async transferClientOwnership(data: ITransferOwnershipRequest): Promise<void> {
+    await this.api.put(`${this.route}transfer_client_ownership`, data);
+  }
+
+  async updateManyWithPersona(data: IUpdateManyWithPersona): Promise<void> {
+    await this.api.put(`${this.route}update_many_with_persona`, data);
+  }
+
+  async sendClientNotification(
+    { id }: Nomalism.shared.IFindByIdRequest,
+    data: ISendClientNotificationRequest,
+  ): Promise<void> {
+    await this.api.post(`${this.route}${id}/send_client_notification`, data);
+  }
+
+  async markUnsentClientNotification({ id }: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.post(`${this.route}${id}/mark_unsent_client_notification`);
+  }
+
+  async documentPdf({ id }: Nomalism.shared.IFindByIdRequest): Promise<string> {
+    const result = await this.api.post(`${this.route}document_pdf/${id}`);
+    return result.data;
+  }
+
+  async documentPdfStream(
+    { id }: Nomalism.shared.IFindByIdRequest,
+    params?: IDocumentPdfRequest,
+  ): Promise<AxiosResponse> {
+    const result = await this.api.get(`${this.route}document_pdf/${id}`, {
+      params,
+      responseType: 'arraybuffer',
+    });
+    return result.data;
+  }
+
+  getDocumentPdfUrl({ id }: Nomalism.shared.IFindByIdRequest, data?: IDocumentPdfRequest): string {
+    const qs = new URLSearchParams();
+    if (data?.token) {
+      qs.set('token', data.token);
+    }
+    return `${this.route}document_pdf/${id}?${qs.toString()}`;
+  }
+
+  async documentList({
+    id,
+  }: Nomalism.shared.IFindByIdRequest): Promise<Nomalism.DocumentHeader.IDocumentListResponse[]> {
+    const result = await this.api.post(`${this.route}document_list/${id}`);
+    return result.data;
+  }
+
+  async getAllRelatedDocumentHeaderIds({
+    id,
+  }: Nomalism.shared.IFindByIdRequest): Promise<string[]> {
+    const result = await this.api.get(`${this.route}related/${id}`);
+    return result.data;
+  }
+
+  async findStartDocumentHeaderSiblings({
+    id,
+  }: Nomalism.shared.IFindByIdRequest): Promise<Nomalism.DocumentHeader.IFindStartDocumentHeaderSiblingsResponse> {
+    const result = await this.api.get(`${this.route}siblings/${id}`);
+    return result.data;
+  }
+
+  async findRmOpenDocuments(): Promise<Nomalism.DocumentHeader.IFindRmOpenDocuments[]> {
+    const response = await this.api.get(`${this.route}rm_open_documents`);
+    return response.data;
+  }
+}