@experteam-mx/ngx-services 18.4.1 → 18.4.2

package/esm2022/lib/apis/api-invoices.service.mjs

@@ -17,13 +17,23 @@ export class ApiInvoicesService {
     get url() {
         return this.environments.apiInvoicesUrl ?? '';
     }
+    /**
+     * Sends an operation document to the server and processes the response.
+     *
+     * @param {OperationDocumentIn} body - The input data for the operation document.
+     * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.
+     */
+    postOperationDocument(body) {
+        return this.http.post(`${this.url}/operation/document`, body)
+            .pipe(map(({ data }) => data));
+    }
     /**
      * Fetches and returns the collection receipt data for a given collection ID.
      *
      * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.
-     * @return {Observable<CollectionReceiptOut>} An observable containing the collection receipt data.
+     * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.
      */
-    printCollectionReceipt(id) {
+    getPrintCollectionReceipt(id) {
         return this.http.get(`${this.url}/operation/print/collection-receipt/${id}`)
             .pipe(map(({ data }) => data));
     }
@@ -31,10 +41,10 @@ export class ApiInvoicesService {
      * Handles the account payment operation by sending a POST request to the specified endpoint.
      * Processes the response and returns the operation data.
      *
-     * @param {AccountPaymentOperationIn} body The payload containing information for the account payment operation.
-     * @return {Observable<AccountPaymentOperationOut>} An observable emitting the processed account payment operation data.
+     * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.
+     * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.
      */
-    accountPaymentOperation(body) {
+    postOperationAccountPayment(body) {
         return this.http.post(`${this.url}/operation/account-payment`, body)
             .pipe(map(({ data }) => data));
     }
@@ -45,7 +55,7 @@ export class ApiInvoicesService {
      * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.
      * @return An Observable representing the result of the cancellation. Emits an empty object on success.
      */
-    cancelPaymentReceipt(body) {
+    postOperationCancelDocument(body) {
         return this.http.post(`${this.url}/operation/cancel-document`, body)
             .pipe(map(({ data }) => data));
     }
@@ -55,10 +65,70 @@ export class ApiInvoicesService {
      * @param {Object} parameters - The parameters required to cancel the invoice, encapsulated in a CancelBillingIn object.
      * @return {Observable<Object>} An observable that emits the response of the cancellation operation.
      */
-    cancelInvoice({ invoiceId, ...body }) {
+    postOperationCancelBilling({ invoiceId, ...body }) {
         return this.http.post(`${this.url}/operation/cancel-billing/${invoiceId}`, body)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Fetches a list of customer types from the server.
+     *
+     * @param {QueryParams} params - Query parameters to filter or customize the request.
+     * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.
+     */
+    getCustomerTypes(params) {
+        return this.http.get(`${this.url}/customer-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves document types specific to a given country.
+     *
+     * @param {QueryParams} params - The query parameters containing country-specific information.
+     * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.
+     */
+    getCustomerDocumentTypes(params) {
+        return this.http.get(`${this.url}/customer-country-document-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches customer invoice details filtered by a custom invoice type.
+     *
+     * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.
+     * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.
+     */
+    getCustomers(params) {
+        return this.http.get(`${this.url}/customers`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update an external shipment operation.
+     *
+     * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.
+     * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.
+     */
+    postOperationShipmentExternal(params) {
+        return this.http.post(`${this.url}/operation/shipment/external`, params)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Processes an external payment operation for a shipment.
+     *
+     * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.
+     * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.
+     */
+    postOperationShipmentExternalPayment(params) {
+        return this.http.post(`${this.url}/operation/shipment/external/payment`, params)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves and returns billing operation print details for a given document ID.
+     *
+     * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.
+     * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.
+     */
+    getOperationPrintDocument(documentId) {
+        return this.http.get(`${this.url}/operation/print/document/${documentId}`)
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInvoicesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInvoicesService, providedIn: 'root' });
 }
@@ -71,4 +141,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-invoices.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-invoices.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EAAE,GAAG,EAAc,MAAM,MAAM,CAAA;;;AAuBtC,MAAM,OAAO,kBAAkB;IAEJ;IACf;IAFV,YACyB,YAAyB,EACxC,IAAgB;QADD,iBAAY,GAAZ,YAAY,CAAa;QACxC,SAAI,GAAJ,IAAI,CAAY;IACtB,CAAC;IAEL;;;;OAIG;IACH,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,IAAI,EAAE,CAAA;IAC/C,CAAC;IAED;;;;;OAKG;IACH,qBAAqB,CAAE,IAAyB;QAC9C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAmC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE,IAAI,CAAC;aAC5F,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAE,EAAU;QACnC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAwC,GAAG,IAAI,CAAC,GAAG,uCAAuC,EAAE,EAAE,CAAC;aAChH,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;;OAMG;IACH,2BAA2B,CAAE,IAA+B;QAC1D,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAyC,GAAG,IAAI,CAAC,GAAG,4BAA4B,EAAE,IAAI,CAAC;aACzG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;;OAMG;IACH,2BAA2B,CAAE,IAA4B;QACvD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiB,GAAG,IAAI,CAAC,GAAG,4BAA4B,EAAE,IAAI,CAAC;aACjF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,0BAA0B,CAAE,EAAE,SAAS,EAAE,GAAG,IAAI,EAA4B;QAC1E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiB,GAAG,IAAI,CAAC,GAAG,6BAA6B,SAAS,EAAE,EAAE,IAAI,CAAC;aAC7F,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAE,MAAmB;QACnC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA+B,GAAG,IAAI,CAAC,GAAG,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAAC;aACzF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,wBAAwB,CAAE,MAAmB;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAuC,GAAG,IAAI,CAAC,GAAG,kCAAkC,EAAE,EAAE,MAAM,EAAE,CAAC;aAClH,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAE,MAAmB;QAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA2B,GAAG,IAAI,CAAC,GAAG,YAAY,EAAE,EAAE,MAAM,EAAE,CAAC;aAChF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,6BAA6B,CAAE,MAAmC;QAChE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA2C,GAAG,IAAI,CAAC,GAAG,8BAA8B,EAAE,MAAM,CAAC;aAC/G,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,oCAAoC,CAAE,MAAmC;QACvE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA2C,GAAG,IAAI,CAAC,GAAG,sCAAsC,EAAE,MAAM,CAAC;aACvH,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAE,UAAkB;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAwC,GAAG,IAAI,CAAC,GAAG,6BAA6B,UAAU,EAAE,CAAC;aAC9G,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;wGAxIU,kBAAkB,kBAEnB,KAAK;4GAFJ,kBAAkB,cAFjB,MAAM;;4FAEP,kBAAkB;kBAH9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAGI,MAAM;2BAAC,KAAK","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\nimport { map, Observable } from 'rxjs'\r\nimport { Environment } from '../ngx-services.models'\r\nimport {\r\n  CancelPaymentReceiptIn,\r\n  CustomerDocumentTypesOut,\r\n  CustomersOut,\r\n  CustomerTypesOut,\r\n  InvoiceTypeCustomParamsIn,\r\n  OperationAccountPaymentIn,\r\n  OperationAccountPaymentOut,\r\n  OperationCancelBillingIn,\r\n  OperationDocumentIn,\r\n  OperationDocumentOut,\r\n  OperationPrintDocumentOut,\r\n  OperationShipmentExternalIn,\r\n  OperationShipmentExternalOut,\r\n  PrintCollectionReceiptOut\r\n} from './models/api-invoices.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInvoicesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the API URL for invoices from the environments configuration.\r\n   *\r\n   * @return {string} The API URL for invoices.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInvoicesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Sends an operation document to the server and processes the response.\r\n   *\r\n   * @param {OperationDocumentIn} body - The input data for the operation document.\r\n   * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.\r\n   */\r\n  postOperationDocument (body: OperationDocumentIn): Observable<OperationDocumentOut> {\r\n    return this.http.post<ApiSuccess<OperationDocumentOut>>(`${this.url}/operation/document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches and returns the collection receipt data for a given collection ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.\r\n   * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.\r\n   */\r\n  getPrintCollectionReceipt (id: number): Observable<PrintCollectionReceiptOut> {\r\n    return this.http.get<ApiSuccess<PrintCollectionReceiptOut>>(`${this.url}/operation/print/collection-receipt/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Handles the account payment operation by sending a POST request to the specified endpoint.\r\n   * Processes the response and returns the operation data.\r\n   *\r\n   * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.\r\n   * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.\r\n   */\r\n  postOperationAccountPayment (body: OperationAccountPaymentIn): Observable<OperationAccountPaymentOut> {\r\n    return this.http.post<ApiSuccess<OperationAccountPaymentOut>>(`${this.url}/operation/account-payment`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels a payment receipt based on the provided input.\r\n   * This method sends a POST request to cancel a document.\r\n   *\r\n   * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.\r\n   * @return An Observable representing the result of the cancellation. Emits an empty object on success.\r\n   */\r\n  postOperationCancelDocument (body: CancelPaymentReceiptIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels an invoice based on the provided invoice ID and additional parameters.\r\n   *\r\n   * @param {Object} parameters - The parameters required to cancel the invoice, encapsulated in a CancelBillingIn object.\r\n   * @return {Observable<Object>} An observable that emits the response of the cancellation operation.\r\n   */\r\n  postOperationCancelBilling ({ invoiceId, ...body }: OperationCancelBillingIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-billing/${invoiceId}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of customer types from the server.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.\r\n   */\r\n  getCustomerTypes (params: QueryParams): Observable<CustomerTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerTypesOut>>(`${this.url}/customer-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves document types specific to a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters containing country-specific information.\r\n   * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.\r\n   */\r\n  getCustomerDocumentTypes (params: QueryParams): Observable<CustomerDocumentTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerDocumentTypesOut>>(`${this.url}/customer-country-document-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches customer invoice details filtered by a custom invoice type.\r\n   *\r\n   * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.\r\n   * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.\r\n   */\r\n  getCustomers (params: QueryParams): Observable<CustomersOut> {\r\n    return this.http.get<ApiSuccess<CustomersOut>>(`${this.url}/customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update an external shipment operation.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.\r\n   */\r\n  postOperationShipmentExternal (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Processes an external payment operation for a shipment.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.\r\n   */\r\n  postOperationShipmentExternalPayment (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external/payment`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns billing operation print details for a given document ID.\r\n   *\r\n   * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.\r\n   * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.\r\n   */\r\n  getOperationPrintDocument (documentId: number): Observable<OperationPrintDocumentOut> {\r\n    return this.http.get<ApiSuccess<OperationPrintDocumentOut>>(`${this.url}/operation/print/document/${documentId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

package/esm2022/lib/apis/api-open-items.service.mjs

@@ -0,0 +1,62 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiOpenItemsService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the API URL for open-items from the environments' configuration.
+     *
+     * @return {string} The API URL for open-items.
+     */
+    get url() {
+        return this.environments.apiOpenItemsUrl ?? '';
+    }
+    /**
+     * Retrieves a list of open-items based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters to use for querying open-items.
+     * @return {Observable<OpenItemsOut>} An observable that emits the open-item's data.
+     */
+    getOpenItems(params) {
+        return this.http.get(`${this.url}/open-items`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Processes a payment for an open item.
+     *
+     * @param {PaymentOpenItemIn} body - The payment details for the open item.
+     * @return {Observable<PaymentOut>} An observable that emits the result of the payment processing.
+     */
+    postPayment(body) {
+        return this.http.post(`${this.url}/payment`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Processes a payment for other invoice.
+     *
+     * @param {OtherInvoiceIn} body - The payment details for the other invoice.
+     * @return {Observable<OtherInvoiceOut>} An observable that emits the result of the payment processing.
+     */
+    postOtherInvoice(body) {
+        return this.http.post(`${this.url}/other-invoices`, body)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiOpenItemsService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiOpenItemsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiOpenItemsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/apis/api-reports.service.mjs

@@ -28,6 +28,52 @@ export class ApiReportsService {
             params
         }).pipe(map(({ data }) => data));
     }
+    /**
+     * Fetches the list of shipments with pending payments.
+     *
+     * @param {ExistPendingPaymentsIn} params - The parameters to filter pending payment shipments.
+     * @return {Observable<ShipmentsReportOut>} An observable emitting the shipments report data.
+     */
+    shipmentsPendingPayments(params) {
+        return this.http.get(`${this.url}/shipments-report`, {
+            params: {
+                ...params,
+                limit: 1,
+                offset: 0,
+                to_landing: true,
+                shipment_status_code: 'PMPEN',
+            },
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches shipment reports that are pending invoices based on the specified parameters.
+     * This method retrieves a filtered list of shipments with pending invoice statuses.
+     *
+     * @param {ExistPendingInvoicesIn} params - The parameters to filter the pending invoices, including
+     *                                           shipment status codes, and pagination options.
+     * @return {Observable<ShipmentsReportOut>} An observable that emits the shipment report data based on the filter criteria.
+     */
+    shipmentsPendingInvoices(params) {
+        return this.http.get(`${this.url}/shipments-report`, {
+            params: {
+                ...params,
+                limit: 1,
+                offset: 0,
+                to_landing: true,
+                'shipment_status_code[in]': 'IPMPE,IMPEN,IPPEN',
+            },
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches shipment reports based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter or define the shipment reports.
+     * @return {Observable<ShipmentsReportOut>} An observable emitting the shipment report data.
+     */
+    getShipmentsReport(params) {
+        return this.http.get(`${this.url}/shipments-report`, { params })
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiReportsService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiReportsService, providedIn: 'root' });
 }
@@ -40,4 +86,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXJlcG9ydHMuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2V4cGVydGVhbS1teC9uZ3gtc2VydmljZXMvc3JjL2xpYi9hcGlzL2FwaS1yZXBvcnRzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFHbEQsT0FBTyxFQUFFLEdBQUcsRUFBYyxNQUFNLE1BQU0sQ0FBQTs7O0FBWXRDLE1BQU0sT0FBTyxpQkFBaUI7SUFFSDtJQUNmO0lBRlYsWUFDeUIsWUFBeUIsRUFDeEMsSUFBZ0I7UUFERCxpQkFBWSxHQUFaLFlBQVksQ0FBYTtRQUN4QyxTQUFJLEdBQUosSUFBSSxDQUFZO0lBQ3RCLENBQUM7SUFFTDs7OztPQUlHO0lBQ0gsSUFBSSxHQUFHO1FBQ0wsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLGFBQWEsSUFBSSxFQUFFLENBQUE7SUFDOUMsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gscUJBQXFCLENBQUUsTUFBbUI7UUFDeEMsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBb0MsR0FBRyxJQUFJLENBQUMsR0FBRyxxQkFBcUIsRUFBRTtZQUN4RixNQUFNO1NBQ1AsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFBO0lBQ2xDLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILHdCQUF3QixDQUFFLE1BQThCO1FBQ3RELE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQWlDLEdBQUcsSUFBSSxDQUFDLEdBQUcsbUJBQW1CLEVBQUU7WUFDbkYsTUFBTSxFQUFFO2dCQUNOLEdBQUcsTUFBTTtnQkFDVCxLQUFLLEVBQUUsQ0FBQztnQkFDUixNQUFNLEVBQUUsQ0FBQztnQkFDVCxVQUFVLEVBQUUsSUFBSTtnQkFDaEIsb0JBQW9CLEVBQUUsT0FBTzthQUM5QjtTQUNGLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQTtJQUNsQyxDQUFDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILHdCQUF3QixDQUFFLE1BQThCO1FBQ3RELE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQWlDLEdBQUcsSUFBSSxDQUFDLEdBQUcsbUJBQW1CLEVBQUU7WUFDbkYsTUFBTSxFQUFFO2dCQUNOLEdBQUcsTUFBTTtnQkFDVCxLQUFLLEVBQUUsQ0FBQztnQkFDUixNQUFNLEVBQUUsQ0FBQztnQkFDVCxVQUFVLEVBQUUsSUFBSTtnQkFDaEIsMEJBQTBCLEVBQUUsbUJBQW1CO2FBQ2hEO1NBQ0YsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFBO0lBQ2xDLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILGtCQUFrQixDQUFFLE1BQW1CO1FBQ3JDLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQWlDLEdBQUcsSUFBSSxDQUFDLEdBQUcsbUJBQW1CLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQzthQUM3RixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQTtJQUNsQyxDQUFDO3dHQTFFVSxpQkFBaUIsa0JBRWxCLEtBQUs7NEdBRkosaUJBQWlCLGNBRmhCLE1BQU07OzRGQUVQLGlCQUFpQjtrQkFIN0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7OzBCQUdJLE1BQU07MkJBQUMsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXHJcbmltcG9ydCB7IEVudmlyb25tZW50IH0gZnJvbSAnLi4vbmd4LXNlcnZpY2VzLm1vZGVscydcclxuaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJ1xyXG5pbXBvcnQgeyBtYXAsIE9ic2VydmFibGUgfSBmcm9tICdyeGpzJ1xyXG5pbXBvcnQgeyBBcGlTdWNjZXNzLCBRdWVyeVBhcmFtcyB9IGZyb20gJy4vbW9kZWxzL2FwaS5tb2RlbHMnXHJcbmltcG9ydCB7XHJcbiAgQ29sbGVjdGlvblBheW1lbnRzT3V0LFxyXG4gIEV4aXN0UGVuZGluZ0ludm9pY2VzSW4sXHJcbiAgRXhpc3RQZW5kaW5nUGF5bWVudHNJbixcclxuICBTaGlwbWVudHNSZXBvcnRPdXRcclxufSBmcm9tICcuL21vZGVscy9hcGktcmVwb3J0cy50eXBlcydcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIEFwaVJlcG9ydHNTZXJ2aWNlIHtcclxuICBjb25zdHJ1Y3RvciAoXHJcbiAgICBASW5qZWN0KCdlbnYnKSBwcml2YXRlIGVudmlyb25tZW50czogRW52aXJvbm1lbnQsXHJcbiAgICBwcml2YXRlIGh0dHA6IEh0dHBDbGllbnRcclxuICApIHsgfVxyXG5cclxuICAvKipcclxuICAgKiBSZXRyaWV2ZXMgdGhlIFVSTCBmb3IgdGhlIHJlcG9ydHMgQVBJIGZyb20gdGhlIGVudmlyb25tZW50IGNvbmZpZ3VyYXRpb25zLlxyXG4gICAqXHJcbiAgICogQHJldHVybiB7c3RyaW5nfSBUaGUgVVJMIG9mIHRoZSByZXBvcnRzIEFQSS5cclxuICAgKi9cclxuICBnZXQgdXJsICgpOiBzdHJpbmcge1xyXG4gICAgcmV0dXJuIHRoaXMuZW52aXJvbm1lbnRzLmFwaVJlcG9ydHNVcmwgPz8gJydcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIFJldHJpZXZlcyB0aGUgbGlzdCBvZiBjb2xsZWN0aW9uIHBheW1lbnRzXHJcbiAgICpcclxuICAgKiBAcGFyYW0ge1F1ZXJ5UGFyYW1zfSBwYXJhbXMgLSBUaGUgcXVlcnkgcGFyYW1ldGVycyB1c2VkIHRvIGZldGNoIHRoZSBjb2xsZWN0aW9uIHBheW1lbnRzLlxyXG4gICAqIEByZXR1cm4ge09ic2VydmFibGU8Q29sbGVjdGlvblBheW1lbnRzT3V0W10+fSBBbiBvYnNlcnZhYmxlIHRoYXQgZW1pdHMgYW4gYXJyYXkgb2YgY29sbGVjdGlvbiBwYXltZW50LlxyXG4gICAqL1xyXG4gIGdldENvbGxlY3Rpb25QYXltZW50cyAocGFyYW1zOiBRdWVyeVBhcmFtcyk6IE9ic2VydmFibGU8Q29sbGVjdGlvblBheW1lbnRzT3V0PiB7XHJcbiAgICByZXR1cm4gdGhpcy5odHRwLmdldDxBcGlTdWNjZXNzPENvbGxlY3Rpb25QYXltZW50c091dD4+KGAke3RoaXMudXJsfS9jb2xsZWN0aW9uLXBheW1lbnRgLCB7XHJcbiAgICAgIHBhcmFtc1xyXG4gICAgfSkucGlwZShtYXAoKHsgZGF0YSB9KSA9PiBkYXRhKSlcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEZldGNoZXMgdGhlIGxpc3Qgb2Ygc2hpcG1lbnRzIHdpdGggcGVuZGluZyBwYXltZW50cy5cclxuICAgKlxyXG4gICAqIEBwYXJhbSB7RXhpc3RQZW5kaW5nUGF5bWVudHNJbn0gcGFyYW1zIC0gVGhlIHBhcmFtZXRlcnMgdG8gZmlsdGVyIHBlbmRpbmcgcGF5bWVudCBzaGlwbWVudHMuXHJcbiAgICogQHJldHVybiB7T2JzZXJ2YWJsZTxTaGlwbWVudHNSZXBvcnRPdXQ+fSBBbiBvYnNlcnZhYmxlIGVtaXR0aW5nIHRoZSBzaGlwbWVudHMgcmVwb3J0IGRhdGEuXHJcbiAgICovXHJcbiAgc2hpcG1lbnRzUGVuZGluZ1BheW1lbnRzIChwYXJhbXM6IEV4aXN0UGVuZGluZ1BheW1lbnRzSW4pOiBPYnNlcnZhYmxlPFNoaXBtZW50c1JlcG9ydE91dD4ge1xyXG4gICAgcmV0dXJuIHRoaXMuaHR0cC5nZXQ8QXBpU3VjY2VzczxTaGlwbWVudHNSZXBvcnRPdXQ+PihgJHt0aGlzLnVybH0vc2hpcG1lbnRzLXJlcG9ydGAsIHtcclxuICAgICAgcGFyYW1zOiB7XHJcbiAgICAgICAgLi4ucGFyYW1zLFxyXG4gICAgICAgIGxpbWl0OiAxLFxyXG4gICAgICAgIG9mZnNldDogMCxcclxuICAgICAgICB0b19sYW5kaW5nOiB0cnVlLFxyXG4gICAgICAgIHNoaXBtZW50X3N0YXR1c19jb2RlOiAnUE1QRU4nLFxyXG4gICAgICB9LFxyXG4gICAgfSkucGlwZShtYXAoKHsgZGF0YSB9KSA9PiBkYXRhKSlcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEZldGNoZXMgc2hpcG1lbnQgcmVwb3J0cyB0aGF0IGFyZSBwZW5kaW5nIGludm9pY2VzIGJhc2VkIG9uIHRoZSBzcGVjaWZpZWQgcGFyYW1ldGVycy5cclxuICAgKiBUaGlzIG1ldGhvZCByZXRyaWV2ZXMgYSBmaWx0ZXJlZCBsaXN0IG9mIHNoaXBtZW50cyB3aXRoIHBlbmRpbmcgaW52b2ljZSBzdGF0dXNlcy5cclxuICAgKlxyXG4gICAqIEBwYXJhbSB7RXhpc3RQZW5kaW5nSW52b2ljZXNJbn0gcGFyYW1zIC0gVGhlIHBhcmFtZXRlcnMgdG8gZmlsdGVyIHRoZSBwZW5kaW5nIGludm9pY2VzLCBpbmNsdWRpbmdcclxuICAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzaGlwbWVudCBzdGF0dXMgY29kZXMsIGFuZCBwYWdpbmF0aW9uIG9wdGlvbnMuXHJcbiAgICogQHJldHVybiB7T2JzZXJ2YWJsZTxTaGlwbWVudHNSZXBvcnRPdXQ+fSBBbiBvYnNlcnZhYmxlIHRoYXQgZW1pdHMgdGhlIHNoaXBtZW50IHJlcG9ydCBkYXRhIGJhc2VkIG9uIHRoZSBmaWx0ZXIgY3JpdGVyaWEuXHJcbiAgICovXHJcbiAgc2hpcG1lbnRzUGVuZGluZ0ludm9pY2VzIChwYXJhbXM6IEV4aXN0UGVuZGluZ0ludm9pY2VzSW4pOiBPYnNlcnZhYmxlPFNoaXBtZW50c1JlcG9ydE91dD4ge1xyXG4gICAgcmV0dXJuIHRoaXMuaHR0cC5nZXQ8QXBpU3VjY2VzczxTaGlwbWVudHNSZXBvcnRPdXQ+PihgJHt0aGlzLnVybH0vc2hpcG1lbnRzLXJlcG9ydGAsIHtcclxuICAgICAgcGFyYW1zOiB7XHJcbiAgICAgICAgLi4ucGFyYW1zLFxyXG4gICAgICAgIGxpbWl0OiAxLFxyXG4gICAgICAgIG9mZnNldDogMCxcclxuICAgICAgICB0b19sYW5kaW5nOiB0cnVlLFxyXG4gICAgICAgICdzaGlwbWVudF9zdGF0dXNfY29kZVtpbl0nOiAnSVBNUEUsSU1QRU4sSVBQRU4nLFxyXG4gICAgICB9LFxyXG4gICAgfSkucGlwZShtYXAoKHsgZGF0YSB9KSA9PiBkYXRhKSlcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEZldGNoZXMgc2hpcG1lbnQgcmVwb3J0cyBiYXNlZCBvbiB0aGUgcHJvdmlkZWQgcXVlcnkgcGFyYW1ldGVycy5cclxuICAgKlxyXG4gICAqIEBwYXJhbSB7UXVlcnlQYXJhbXN9IHBhcmFtcyAtIFRoZSBxdWVyeSBwYXJhbWV0ZXJzIHVzZWQgdG8gZmlsdGVyIG9yIGRlZmluZSB0aGUgc2hpcG1lbnQgcmVwb3J0cy5cclxuICAgKiBAcmV0dXJuIHtPYnNlcnZhYmxlPFNoaXBtZW50c1JlcG9ydE91dD59IEFuIG9ic2VydmFibGUgZW1pdHRpbmcgdGhlIHNoaXBtZW50IHJlcG9ydCBkYXRhLlxyXG4gICAqL1xyXG4gIGdldFNoaXBtZW50c1JlcG9ydCAocGFyYW1zOiBRdWVyeVBhcmFtcyk6IE9ic2VydmFibGU8U2hpcG1lbnRzUmVwb3J0T3V0PiB7XHJcbiAgICByZXR1cm4gdGhpcy5odHRwLmdldDxBcGlTdWNjZXNzPFNoaXBtZW50c1JlcG9ydE91dD4+KGAke3RoaXMudXJsfS9zaGlwbWVudHMtcmVwb3J0YCwgeyBwYXJhbXMgfSlcclxuICAgICAgLnBpcGUobWFwKCh7IGRhdGEgfSkgPT4gZGF0YSkpXHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2022/lib/apis/api-security.service.mjs

@@ -22,20 +22,22 @@ export class ApiSecurityService {
         return this.environments.apiSecurityUrl ?? '';
     }
     /**
-     * Authenticates a user with the provided credentials and role.
+     * Performs user authentication by sending login credentials to the server.
      *
-     * @param {Object} param0 - The login input object.
-     * @param {string} param0.username - The username of the user.
-     * @param {string} param0.password - The password of the user.
-     * @param {string} param0.role - The role of the user.
-     * @return {Observable<LoginOut>} An observable emitting the login output object.
+     * @param {Object} params - An object containing the user's login credentials and system details.
+     * @param {string} params.username - The username of the user attempting to log in.
+     * @param {string} params.password - The user's password.
+     * @param {string} params.role - The role of the user (e.g., admin, user).
+     * @param {string} params.system_name - The name of the system the user is logging into.
+     *
+     * @return {Observable<AuthLoginOut>} An observable that emits the authentication result, including tokens and user information.
      */
-    login({ username, password, role, }) {
+    postAuthLogin({ username, password, role, system_name }) {
         return this.http.post(`${this.url}/auth/login`, {
-            system_name: 'CRA',
             username,
             password,
             role,
+            system_name,
         }).pipe(map(({ data }) => data), tap(({ access_token }) => this.cookie.set(this.environments.authCookie, access_token, { path: '/' })));
     }
     /**
@@ -45,7 +47,7 @@ export class ApiSecurityService {
      *
      * @return {Observable<{}>} An observable that emits the server's response to the logout request.
      */
-    logout() {
+    postAuthLogout() {
         return this.http.post(`${this.url}/auth/logout`, null)
             .pipe(map(({ data }) => data), tap(() => this.cookie.delete(this.environments.authCookie, '/')));
     }
@@ -57,9 +59,9 @@ export class ApiSecurityService {
      * @param {string} params.modelId - The ID of the model.
      * @param {string} [params.token] - Optional authorization token.
      *
-     * @return {Observable<CreateSessionOut>} An observable containing the created session details.
+     * @return {Observable<SessionOut>} An observable containing the created session details.
      */
-    createSession({ modelType, modelId, token, }) {
+    postSession({ modelType, modelId, token, }) {
         let headers = new HttpHeaders({});
         if (token) {
             headers = headers.set('Authorization', `Bearer ${token}`);
@@ -76,9 +78,9 @@ export class ApiSecurityService {
      * Sends a GET request to the endpoint '/auth/me' to retrieve information
      * about the currently authenticated user.
      *
-     * @return {Observable<MeOut>} An observable that emits the authenticated user's data.
+     * @return {Observable<AuthMeOut>} An observable that emits the authenticated user's data.
      */
-    me() {
+    getAuthMe() {
         return this.http.get(`${this.url}/auth/me`)
             .pipe(map(({ data }) => data));
     }
@@ -88,7 +90,7 @@ export class ApiSecurityService {
      * @param token The JWT token used for authorization.
      * @return An Observable that emits the user's details encapsulated in a MeOut object.
      */
-    otherMe(token) {
+    getOtherMe(token) {
         return this.http.get(`${this.url}/auth/me`, {
             headers: {
                 Authorization: `Bearer ${token}`
@@ -101,7 +103,7 @@ export class ApiSecurityService {
      * @param {number} id - The unique identifier of the user to be fetched.
      * @return {Observable<GetUserOut>} An observable containing the user information.
      */
-    user(id) {
+    getUser(id) {
         return this.http.get(`${this.url}/users/${id}`)
             .pipe(map(({ data }) => data));
     }
@@ -110,9 +112,9 @@ export class ApiSecurityService {
      *
      * @param {Object} params - The input parameters for changing the language.
      * @param {string} params.languageId - The ID of the new language to be set.
-     * @return {Observable<ApiSuccess<MeOut>>} An observable that emits the result of the language change request.
+     * @return {Observable<ApiSuccess<AuthMeOut>>} An observable that emits the result of the language change request.
      */
-    changeLanguage({ languageId }) {
+    putChangeLanguage({ languageId }) {
         return this.http.put(`${this.url}/auth/me`, {
             language_id: languageId
         }).pipe(map(({ data }) => data));
@@ -121,7 +123,7 @@ export class ApiSecurityService {
      * Retrieves a list of roles with their permissions.
      *
      * @param {QueryParams} params - The query parameters to filter the roles.
-     * @returns {Observable<RolePermissionsIn[]>} An observable that emits an array of role permissions.
+     * @returns {Observable<RoleIn[]>} An observable that emits an array of role permissions.
      */
     getRoles(params) {
         return this.http.get(`${this.url}/roles`, {
@@ -139,34 +141,23 @@ export class ApiSecurityService {
             params
         }).pipe(map(({ data }) => data));
     }
-    /**
-     * Retrieves the permissions for a module.
-     *
-     * @param {QueryParams} params - The query parameters to be sent with the request.
-     * @returns {Observable<ModulePermissionsOut>} An observable containing the module permissions.
-     */
-    getPermissions(params) {
-        return this.http.get(`${this.url}/modules`, {
-            params
-        }).pipe(map(({ data }) => data));
-    }
     /**
      * Retrieves roles by the specified ID.
      *
-     * @param params - The ID of the role to retrieve.
+     * @param id - The ID of the role to retrieve.
      * @returns An Observable that emits the role data.
      */
-    getRolesById(params) {
-        return this.http.get(`${this.url}/roles/${params}`)
+    getRole(id) {
+        return this.http.get(`${this.url}/roles/${id}`)
             .pipe(map(({ data }) => data));
     }
     /**
      * Creates a new role with the specified permissions.
      *
-     * @param {RolePermissionsIn} body - The permissions and details for the new role.
-     * @returns {Observable<ModulePermissionsOut>} An observable containing the created role's permissions.
+     * @param {RoleIn} body - The permissions and details for the new role.
+     * @returns {Observable<RoleOut>} An observable containing the created role's permissions.
      */
-    createRole(body) {
+    postRole(body) {
         return this.http.post(`${this.url}/roles`, body)
             .pipe(map(({ data }) => data));
     }
@@ -177,7 +168,7 @@ export class ApiSecurityService {
      * @param body - The new permissions to assign to the role.
      * @returns An Observable that emits the updated module permissions.
      */
-    updateRolePermissions(id, body) {
+    putRole(id, body) {
         return this.http.put(`${this.url}/roles/${id}`, body)
             .pipe(map(({ data }) => data));
     }
@@ -187,10 +178,36 @@ export class ApiSecurityService {
      * @param {number} id - The unique identifier of the role whose permissions are to be deleted.
      * @returns {Observable<{}>} An observable that emits the result of the delete operation.
      */
-    deleteRolePermissions(id) {
+    deleteRole(id) {
         return this.http.delete(`${this.url}/roles/${id}`)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Retrieves a list of modules and permissions
+     *
+     * @param queryParams - The query parameters to filter the modules.
+     * @returns Observable<ModulesOut[]> - An observable that emits an array of modules and permissions.
+     */
+    getModules(queryParams) {
+        return this.http.get(`${this.url}/modules`, {
+            params: queryParams
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of modules and permissions
+     *
+     * @param params.token - Custom token for authorization.
+     * @param params.queryParams - The query parameters to filter the modules.
+     * @returns Observable<ModulesOut[]> - An observable that emits an array of modules and permissions.
+     */
+    getModulesByToken(params) {
+        return this.http.get(`${this.url}/modules`, {
+            params: params.queryParams,
+            headers: {
+                Authorization: `Bearer ${params.token}`
+            }
+        }).pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiSecurityService, deps: [{ token: 'env' }, { token: i1.CookieService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiSecurityService, providedIn: 'root' });
 }
@@ -203,4 +220,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.CookieService }, { type: i2.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-security.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-security.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport {\r\n  ChangeLanguageIn,\r\n  CreateSessionIn,\r\n  CreateSessionOut,\r\n  GetUserOut,\r\n  LoginIn,\r\n  LoginOut,\r\n  MeOut,\r\n  ModulePermissionsOut,\r\n  RoleByIdOut,\r\n  RolePermissionsIn,\r\n  RolesOut,\r\n  RoleTypesOut\r\n} from './models/api-security.types'\r\nimport { HttpClient, HttpHeaders } from '@angular/common/http'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { map, Observable, tap } from 'rxjs'\r\nimport { CookieService } from 'ngx-cookie-service'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiSecurityService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private cookie: CookieService,\r\n    private http: HttpClient\r\n  ) {}\r\n\r\n  /**\r\n   * Retrieves the API security URL from the environments configuration.\r\n   *\r\n   * @return {string} The API security URL.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiSecurityUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Authenticates a user with the provided credentials and role.\r\n   *\r\n   * @param {Object} param0 - The login input object.\r\n   * @param {string} param0.username - The username of the user.\r\n   * @param {string} param0.password - The password of the user.\r\n   * @param {string} param0.role - The role of the user.\r\n   * @return {Observable<LoginOut>} An observable emitting the login output object.\r\n   */\r\n  login ({\r\n    username,\r\n    password,\r\n    role,\r\n  }: LoginIn): Observable<LoginOut> {\r\n    return this.http.post<ApiSuccess<LoginOut>>(`${this.url}/auth/login`, {\r\n      system_name: 'CRA',\r\n      username,\r\n      password,\r\n      role,\r\n    }).pipe(\r\n      map(({ data }) => data),\r\n      tap(({ access_token }) => this.cookie.set(this.environments.authCookie, access_token, { path: '/' }))\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Logs out the current user by making a POST request to the logout endpoint.\r\n   *\r\n   * This method deletes all cookies after a successful logout.\r\n   *\r\n   * @return {Observable<{}>} An observable that emits the server's response to the logout request.\r\n   */\r\n  logout (): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/auth/logout`, null)\r\n      .pipe(\r\n        map(({ data }) => data),\r\n        tap(() => this.cookie.delete(this.environments.authCookie, '/'))\r\n      )\r\n  }\r\n\r\n  /**\r\n   * Creates a new session for a specified model.\r\n   *\r\n   * @param {Object} params - The parameters for creating the session.\r\n   * @param {string} params.modelType - The type of the model.\r\n   * @param {string} params.modelId - The ID of the model.\r\n   * @param {string} [params.token] - Optional authorization token.\r\n   *\r\n   * @return {Observable<CreateSessionOut>} An observable containing the created session details.\r\n   */\r\n  createSession ({\r\n    modelType,\r\n    modelId,\r\n    token,\r\n  }: CreateSessionIn): Observable<CreateSessionOut> {\r\n    let headers = new HttpHeaders({})\r\n\r\n    if (token) { headers = headers.set('Authorization', `Bearer ${token}`) }\r\n\r\n    return this.http.post<ApiSuccess<CreateSessionOut>>(\r\n      `${this.url}/sessions`, {\r\n        model_type: modelType,\r\n        model_id: modelId,\r\n      }, {\r\n        headers\r\n      }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the authenticated user's information.\r\n   * Sends a GET request to the endpoint '/auth/me' to retrieve information\r\n   * about the currently authenticated user.\r\n   *\r\n   * @return {Observable<MeOut>} An observable that emits the authenticated user's data.\r\n   */\r\n  me (): Observable<MeOut> {\r\n    return this.http.get<ApiSuccess<MeOut>>(`${this.url}/auth/me`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the authenticated user's details from the server.\r\n   *\r\n   * @param token The JWT token used for authorization.\r\n   * @return An Observable that emits the user's details encapsulated in a MeOut object.\r\n   */\r\n  otherMe (token: string): Observable<MeOut> {\r\n    return this.http.get<ApiSuccess<MeOut>>(`${this.url}/auth/me`, {\r\n      headers: {\r\n        Authorization: `Bearer ${token}`\r\n      }\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a user by their unique ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the user to be fetched.\r\n   * @return {Observable<GetUserOut>} An observable containing the user information.\r\n   */\r\n  user (id: number): Observable<GetUserOut> {\r\n    return this.http.get<ApiSuccess<GetUserOut>>(`${this.url}/users/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Changes the language for the authenticated user.\r\n   *\r\n   * @param {Object} params - The input parameters for changing the language.\r\n   * @param {string} params.languageId - The ID of the new language to be set.\r\n   * @return {Observable<ApiSuccess<MeOut>>} An observable that emits the result of the language change request.\r\n   */\r\n  changeLanguage ({\r\n    languageId\r\n  }: ChangeLanguageIn): Observable<MeOut> {\r\n    return this.http.put<ApiSuccess<MeOut>>(`${this.url}/auth/me`, {\r\n      language_id: languageId\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of roles with their permissions.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the roles.\r\n   * @returns {Observable<RolePermissionsIn[]>} An observable that emits an array of role permissions.\r\n   */\r\n  getRoles(params: QueryParams): Observable<RolesOut> {\r\n    return this.http.get<ApiSuccess<RolesOut>>(`${this.url}/roles`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the role types from the API.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to be sent with the request.\r\n   * @returns {Observable<RoleTypesOut>} An observable containing the role types output.\r\n   */\r\n  getRoleTypes (params: QueryParams): Observable<RoleTypesOut> {\r\n    return this.http.get<ApiSuccess<RoleTypesOut>>(`${this.url}/role-types`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the permissions for a module.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to be sent with the request.\r\n   * @returns {Observable<ModulePermissionsOut>} An observable containing the module permissions.\r\n   */\r\n  getPermissions (params: QueryParams): Observable<ModulePermissionsOut> {\r\n    return this.http.get<ApiSuccess<ModulePermissionsOut>>(`${this.url}/modules`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves roles by the specified ID.\r\n   *\r\n   * @param params - The ID of the role to retrieve.\r\n   * @returns An Observable that emits the role data.\r\n   */\r\n  getRolesById (params: number): Observable<RoleByIdOut> {\r\n    return this.http.get<ApiSuccess<RoleByIdOut>>(`${this.url}/roles/${params}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new role with the specified permissions.\r\n   *\r\n   * @param {RolePermissionsIn} body - The permissions and details for the new role.\r\n   * @returns {Observable<ModulePermissionsOut>} An observable containing the created role's permissions.\r\n   */\r\n  createRole (body: RolePermissionsIn): Observable<ModulePermissionsOut> {\r\n    return this.http.post<ApiSuccess<ModulePermissionsOut>>(`${this.url}/roles`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the permissions of a specific role.\r\n   *\r\n   * @param id - The unique identifier of the role to update.\r\n   * @param body - The new permissions to assign to the role.\r\n   * @returns An Observable that emits the updated module permissions.\r\n   */\r\n  updateRolePermissions (id: number, body: RolePermissionsIn): Observable<ModulePermissionsOut> {\r\n    return this.http.put<ApiSuccess<ModulePermissionsOut>>(`${this.url}/roles/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes the permissions associated with a specific role.\r\n   *\r\n   * @param {number} id - The unique identifier of the role whose permissions are to be deleted.\r\n   * @returns {Observable<{}>} An observable that emits the result of the delete operation.\r\n   */\r\n  deleteRolePermissions (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/roles/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-security.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-security.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport {\r\n  AuthLoginIn,\r\n  AuthLoginOut,\r\n  AuthMeOut,\r\n  ChangeLanguageIn,\r\n  GetUserOut,\r\n  ModulesOut,\r\n  RoleIn,\r\n  RoleOut,\r\n  RolesOut,\r\n  RoleTypesOut,\r\n  SessionIn,\r\n  SessionOut\r\n} from './models/api-security.types'\r\nimport { HttpClient, HttpHeaders } from '@angular/common/http'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { map, Observable, tap } from 'rxjs'\r\nimport { CookieService } from 'ngx-cookie-service'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiSecurityService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private cookie: CookieService,\r\n    private http: HttpClient\r\n  ) {}\r\n\r\n  /**\r\n   * Retrieves the API security URL from the environments configuration.\r\n   *\r\n   * @return {string} The API security URL.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiSecurityUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Performs user authentication by sending login credentials to the server.\r\n   *\r\n   * @param {Object} params - An object containing the user's login credentials and system details.\r\n   * @param {string} params.username - The username of the user attempting to log in.\r\n   * @param {string} params.password - The user's password.\r\n   * @param {string} params.role - The role of the user (e.g., admin, user).\r\n   * @param {string} params.system_name - The name of the system the user is logging into.\r\n   *\r\n   * @return {Observable<AuthLoginOut>} An observable that emits the authentication result, including tokens and user information.\r\n   */\r\n  postAuthLogin ({\r\n    username,\r\n    password,\r\n    role,\r\n    system_name\r\n  }: AuthLoginIn): Observable<AuthLoginOut> {\r\n    return this.http.post<ApiSuccess<AuthLoginOut>>(`${this.url}/auth/login`, {\r\n      username,\r\n      password,\r\n      role,\r\n      system_name,\r\n    }).pipe(\r\n      map(({ data }) => data),\r\n      tap(({ access_token }) => this.cookie.set(this.environments.authCookie, access_token, { path: '/' }))\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Logs out the current user by making a POST request to the logout endpoint.\r\n   *\r\n   * This method deletes all cookies after a successful logout.\r\n   *\r\n   * @return {Observable<{}>} An observable that emits the server's response to the logout request.\r\n   */\r\n  postAuthLogout (): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/auth/logout`, null)\r\n      .pipe(\r\n        map(({ data }) => data),\r\n        tap(() => this.cookie.delete(this.environments.authCookie, '/'))\r\n      )\r\n  }\r\n\r\n  /**\r\n   * Creates a new session for a specified model.\r\n   *\r\n   * @param {Object} params - The parameters for creating the session.\r\n   * @param {string} params.modelType - The type of the model.\r\n   * @param {string} params.modelId - The ID of the model.\r\n   * @param {string} [params.token] - Optional authorization token.\r\n   *\r\n   * @return {Observable<SessionOut>} An observable containing the created session details.\r\n   */\r\n  postSession ({\r\n    modelType,\r\n    modelId,\r\n    token,\r\n  }: SessionIn): Observable<SessionOut> {\r\n    let headers = new HttpHeaders({})\r\n\r\n    if (token) { headers = headers.set('Authorization', `Bearer ${token}`) }\r\n\r\n    return this.http.post<ApiSuccess<SessionOut>>(\r\n      `${this.url}/sessions`, {\r\n        model_type: modelType,\r\n        model_id: modelId,\r\n      }, {\r\n        headers\r\n      }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the authenticated user's information.\r\n   * Sends a GET request to the endpoint '/auth/me' to retrieve information\r\n   * about the currently authenticated user.\r\n   *\r\n   * @return {Observable<AuthMeOut>} An observable that emits the authenticated user's data.\r\n   */\r\n  getAuthMe (): Observable<AuthMeOut> {\r\n    return this.http.get<ApiSuccess<AuthMeOut>>(`${this.url}/auth/me`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the authenticated user's details from the server.\r\n   *\r\n   * @param token The JWT token used for authorization.\r\n   * @return An Observable that emits the user's details encapsulated in a MeOut object.\r\n   */\r\n  getOtherMe (token: string): Observable<AuthMeOut> {\r\n    return this.http.get<ApiSuccess<AuthMeOut>>(`${this.url}/auth/me`, {\r\n      headers: {\r\n        Authorization: `Bearer ${token}`\r\n      }\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a user by their unique ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the user to be fetched.\r\n   * @return {Observable<GetUserOut>} An observable containing the user information.\r\n   */\r\n  getUser (id: number): Observable<GetUserOut> {\r\n    return this.http.get<ApiSuccess<GetUserOut>>(`${this.url}/users/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Changes the language for the authenticated user.\r\n   *\r\n   * @param {Object} params - The input parameters for changing the language.\r\n   * @param {string} params.languageId - The ID of the new language to be set.\r\n   * @return {Observable<ApiSuccess<AuthMeOut>>} An observable that emits the result of the language change request.\r\n   */\r\n  putChangeLanguage ({\r\n    languageId\r\n  }: ChangeLanguageIn): Observable<AuthMeOut> {\r\n    return this.http.put<ApiSuccess<AuthMeOut>>(`${this.url}/auth/me`, {\r\n      language_id: languageId\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of roles with their permissions.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the roles.\r\n   * @returns {Observable<RoleIn[]>} An observable that emits an array of role permissions.\r\n   */\r\n  getRoles (params: QueryParams): Observable<RolesOut> {\r\n    return this.http.get<ApiSuccess<RolesOut>>(`${this.url}/roles`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the role types from the API.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to be sent with the request.\r\n   * @returns {Observable<RoleTypesOut>} An observable containing the role types output.\r\n   */\r\n  getRoleTypes (params: QueryParams): Observable<RoleTypesOut> {\r\n    return this.http.get<ApiSuccess<RoleTypesOut>>(`${this.url}/role-types`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves roles by the specified ID.\r\n   *\r\n   * @param id - The ID of the role to retrieve.\r\n   * @returns An Observable that emits the role data.\r\n   */\r\n  getRole (id: number): Observable<RoleOut> {\r\n    return this.http.get<ApiSuccess<RoleOut>>(`${this.url}/roles/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new role with the specified permissions.\r\n   *\r\n   * @param {RoleIn} body - The permissions and details for the new role.\r\n   * @returns {Observable<RoleOut>} An observable containing the created role's permissions.\r\n   */\r\n  postRole (body: RoleIn): Observable<RoleOut> {\r\n    return this.http.post<ApiSuccess<RoleOut>>(`${this.url}/roles`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the permissions of a specific role.\r\n   *\r\n   * @param id - The unique identifier of the role to update.\r\n   * @param body - The new permissions to assign to the role.\r\n   * @returns An Observable that emits the updated module permissions.\r\n   */\r\n  putRole (id: number, body: RoleIn): Observable<RoleOut> {\r\n    return this.http.put<ApiSuccess<RoleOut>>(`${this.url}/roles/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes the permissions associated with a specific role.\r\n   *\r\n   * @param {number} id - The unique identifier of the role whose permissions are to be deleted.\r\n   * @returns {Observable<{}>} An observable that emits the result of the delete operation.\r\n   */\r\n  deleteRole (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/roles/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of modules and permissions\r\n   *\r\n   * @param queryParams - The query parameters to filter the modules.\r\n   * @returns Observable<ModulesOut[]> - An observable that emits an array of modules and permissions.\r\n   */\r\n  getModules (queryParams: QueryParams): Observable<ModulesOut> {\r\n    return this.http.get<ApiSuccess<ModulesOut>>(`${this.url}/modules`, {\r\n      params: queryParams\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of modules and permissions\r\n   *\r\n   * @param params.token - Custom token for authorization.\r\n   * @param params.queryParams - The query parameters to filter the modules.\r\n   * @returns Observable<ModulesOut[]> - An observable that emits an array of modules and permissions.\r\n   */\r\n  getModulesByToken (params: {\r\n    token: string,\r\n    queryParams: QueryParams\r\n  }): Observable<ModulesOut> {\r\n    return this.http.get<ApiSuccess<ModulesOut>>(`${this.url}/modules`, {\r\n      params: params.queryParams,\r\n      headers: {\r\n        Authorization: `Bearer ${params.token}`\r\n      }\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}