@experteam-mx/ngx-services 18.8.12 → 18.8.14

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

@@ -179,6 +179,20 @@ export class ApiInventoriesService {
         return this.http.delete(`${this.url}/incident-reason-complements/${id}`)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Posts packages that are currently in stock.
+     *
+     * @param body - The input data containing package stock information
+     * @returns {Observable<PackagesInStockOut>} An Observable that emits the packages in stock output data
+     *
+     * @remarks
+     * This method sends a POST request to the `/packages/in-stock` endpoint and
+     * extracts the data property from the API success response.
+     */
+    postPackagesInStock(body) {
+        return this.http.post(`${this.url}/packages/in-stock`, body)
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInventoriesService, 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: ApiInventoriesService, providedIn: 'root' });
 }
@@ -191,4 +205,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-inventories.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-inventories.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\nimport { Environment } from '../ngx-services.models'\nimport { HttpClient } from '@angular/common/http'\nimport { ApiSuccess, QueryParams } from './models/api.models'\nimport { map, Observable } from 'rxjs'\nimport { CheckpointEventReasonsOut, CheckpointsOut, IncidentIn, IncidentOut, IncidentReasonComplementIn, IncidentReasonComplementOut, IncidentReasonComplementsOut, IncidentReasonIn, IncidentReasonOut, IncidentReasonsOut, IncidentsOut } from './models/api-inventories.types'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ApiInventoriesService {\n  constructor (\n    @Inject('env') private environments: Environment,\n    private http: HttpClient\n  ) { }\n\n  /**\n   * Retrieves the URL for the Inventories API from the environment configurations.\n   *\n   * @return {string} The URL of the Inventories API.\n   */\n  get url (): string {\n    return this.environments.apiInventoriesUrl ?? ''\n  }\n\n  /**\n   * Retrieves a list of checkpoints based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the checkpoints.\n   * @returns {Observable<CheckpointsOut>} The list of checkpoints.\n   */\n  getCheckpoints (params: QueryParams): Observable<CheckpointsOut> {\n    return this.http.get<ApiSuccess<CheckpointsOut>>(`${this.url}/checkpoints`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of checkpoint event reasons based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the checkpoint event reasons.\n   * @returns {Observable<CheckpointEventReasonsOut>} The list of checkpoint event reasons.\n   */\n  getCheckpointEventReasons (params: QueryParams): Observable<CheckpointEventReasonsOut> {\n    return this.http.get<ApiSuccess<CheckpointEventReasonsOut>>(`${this.url}/checkpoint-event-reasons`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of incidents based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the incidents.\n   * @returns {Observable<IncidentsOut>} An observable that emits the list of incidents.\n   */\n  getIncidents (params: QueryParams): Observable<IncidentsOut> {\n    return this.http.get<ApiSuccess<IncidentsOut>>(`${this.url}/incidents`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Fetches the incident details based on the provided incident ID.\n   *\n   * @param {number} id - The identifier of the incident record to get detail.\n   * @return {Observable<IncidentOut>} An observable that emits the detail incident data.\n   */\n  getIncident (id: Number): Observable<IncidentOut> {\n    return this.http.get<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Creates a new incident.\n   *\n   * @param {IncidentIn} body - The data for the new incident.\n   * @returns {Observable<IncidentOut>} An observable the created incident detail.\n   */\n  postIncident (body: IncidentIn): Observable<IncidentOut> {\n    return this.http.post<ApiSuccess<IncidentOut>>(`${this.url}/incidents`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Updates an existing incident.\n   *\n   * @param {number} id - The identifier of the incident record to update.\n   * @param {IncidentIn} body - The incident data to be updated.\n   * @returns {Observable<IncidentOut>} An observable detail of the updated incident.\n   */\n  putIncident (id: Number, body: IncidentIn): Observable<IncidentOut> {\n    return this.http.put<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Delete an existing incident.\n   *\n   * @param {number} id - The unique identifier of the incident to be deleted.\n   * @returns {Observable<IncidentOut>} An observable that emits the result of the delete incident.\n   */\n  deleteIncident (id: Number): Observable<IncidentOut> {\n    return this.http.delete<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of incident reasons based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the incident reasons.\n   * @returns {Observable<IncidentReasonsOut>} An observable that emits the list of incident reasons.\n   */\n  getIncidentReasons (params: QueryParams): Observable<IncidentReasonsOut> {\n    return this.http.get<ApiSuccess<IncidentReasonsOut>>(`${this.url}/incident-reasons`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Fetches the incident reason details based on the provided incident reason ID.\n   *\n   * @param {number} id - The identifier of the incident reason record to get detail.\n   * @return {Observable<IncidentReasonOut>} An observable that emits the detail incident reason data.\n   */\n  getIncidentReason (id: Number): Observable<IncidentReasonOut> {\n    return this.http.get<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Creates a new incident reason.\n   *\n   * @param {IncidentReasonIn} body - The data for the new incident reason.\n   * @returns {Observable<IncidentReasonOut>} An observable the created incident reason detail.\n   */\n  postIncidentReason (body: IncidentReasonIn): Observable<IncidentReasonOut> {\n    return this.http.post<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Updates an existing incident reason.\n   *\n   * @param {number} id - The identifier of the incident reason record to update.\n   * @param {IncidentIn} body - The incident reason data to be updated.\n   * @returns {Observable<IncidentReasonOut>} An observable detail of the updated incident reason.\n   */\n  putIncidentReason (id: Number, body: IncidentReasonIn): Observable<IncidentReasonOut> {\n    return this.http.put<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Delete an existing incident reason.\n   *\n   * @param {number} id - The unique identifier of the incident reason to be deleted.\n   * @returns {Observable<IncidentReasonOut>} An observable that emits the result of the delete incident reason.\n   */\n  deleteIncidentReason (id: Number): Observable<IncidentReasonOut> {\n    return this.http.delete<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of incident reason complements based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the incident reason complements.\n   * @returns {Observable<IncidentReasonComplementsOut>} An observable that emits the list of incident reason complements.\n   */\n  getIncidentReasonComplements (params: QueryParams): Observable<IncidentReasonComplementsOut> {\n    return this.http.get<ApiSuccess<IncidentReasonComplementsOut>>(`${this.url}/incident-reason-complements`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Creates a new incident reason complement.\n   *\n   * @param {IncidentReasonIn} body - The data for the new incident reason complement.\n   * @returns {Observable<IncidentReasonComplementOut>} An observable the created incident reason complement detail.\n   */\n  postIncidentReasonComplement (body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut> {\n    return this.http.post<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Updates an existing incident reason complement.\n   *\n   * @param {number} id - The identifier of the incident reason complement record to update.\n   * @param {IncidentIn} body - The incident reason complement data to be updated.\n   * @returns {Observable<IncidentReasonComplementOut>} An observable detail of the updated incident reason complement.\n   */\n  putIncidentReasonComplement (id: Number, body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut> {\n    return this.http.put<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements/${id}`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Delete an existing incident reason complement.\n   *\n   * @param {number} id - The unique identifier of the incident reason complement to be deleted.\n   * @returns {Observable<IncidentReasonComplementOut>} An observable that emits the result of the delete incident reason complement.\n   */\n  deleteIncidentReasonComplement (id: Number): Observable<IncidentReasonComplementOut> {\n    return this.http.delete<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-inventories.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-inventories.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\nimport { Environment } from '../ngx-services.models'\nimport { HttpClient } from '@angular/common/http'\nimport { ApiSuccess, QueryParams } from './models/api.models'\nimport { map, Observable } from 'rxjs'\nimport { CheckpointEventReasonsOut, CheckpointsOut, IncidentIn, IncidentOut, IncidentReasonComplementIn, IncidentReasonComplementOut, IncidentReasonComplementsOut, IncidentReasonIn, IncidentReasonOut, IncidentReasonsOut, IncidentsOut, PackagesInStockIn, PackagesInStockOut } from './models/api-inventories.types'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ApiInventoriesService {\n  constructor (\n    @Inject('env') private environments: Environment,\n    private http: HttpClient\n  ) { }\n\n  /**\n   * Retrieves the URL for the Inventories API from the environment configurations.\n   *\n   * @return {string} The URL of the Inventories API.\n   */\n  get url (): string {\n    return this.environments.apiInventoriesUrl ?? ''\n  }\n\n  /**\n   * Retrieves a list of checkpoints based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the checkpoints.\n   * @returns {Observable<CheckpointsOut>} The list of checkpoints.\n   */\n  getCheckpoints (params: QueryParams): Observable<CheckpointsOut> {\n    return this.http.get<ApiSuccess<CheckpointsOut>>(`${this.url}/checkpoints`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of checkpoint event reasons based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the checkpoint event reasons.\n   * @returns {Observable<CheckpointEventReasonsOut>} The list of checkpoint event reasons.\n   */\n  getCheckpointEventReasons (params: QueryParams): Observable<CheckpointEventReasonsOut> {\n    return this.http.get<ApiSuccess<CheckpointEventReasonsOut>>(`${this.url}/checkpoint-event-reasons`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of incidents based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the incidents.\n   * @returns {Observable<IncidentsOut>} An observable that emits the list of incidents.\n   */\n  getIncidents (params: QueryParams): Observable<IncidentsOut> {\n    return this.http.get<ApiSuccess<IncidentsOut>>(`${this.url}/incidents`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Fetches the incident details based on the provided incident ID.\n   *\n   * @param {number} id - The identifier of the incident record to get detail.\n   * @return {Observable<IncidentOut>} An observable that emits the detail incident data.\n   */\n  getIncident (id: Number): Observable<IncidentOut> {\n    return this.http.get<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Creates a new incident.\n   *\n   * @param {IncidentIn} body - The data for the new incident.\n   * @returns {Observable<IncidentOut>} An observable the created incident detail.\n   */\n  postIncident (body: IncidentIn): Observable<IncidentOut> {\n    return this.http.post<ApiSuccess<IncidentOut>>(`${this.url}/incidents`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Updates an existing incident.\n   *\n   * @param {number} id - The identifier of the incident record to update.\n   * @param {IncidentIn} body - The incident data to be updated.\n   * @returns {Observable<IncidentOut>} An observable detail of the updated incident.\n   */\n  putIncident (id: Number, body: IncidentIn): Observable<IncidentOut> {\n    return this.http.put<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Delete an existing incident.\n   *\n   * @param {number} id - The unique identifier of the incident to be deleted.\n   * @returns {Observable<IncidentOut>} An observable that emits the result of the delete incident.\n   */\n  deleteIncident (id: Number): Observable<IncidentOut> {\n    return this.http.delete<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of incident reasons based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the incident reasons.\n   * @returns {Observable<IncidentReasonsOut>} An observable that emits the list of incident reasons.\n   */\n  getIncidentReasons (params: QueryParams): Observable<IncidentReasonsOut> {\n    return this.http.get<ApiSuccess<IncidentReasonsOut>>(`${this.url}/incident-reasons`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Fetches the incident reason details based on the provided incident reason ID.\n   *\n   * @param {number} id - The identifier of the incident reason record to get detail.\n   * @return {Observable<IncidentReasonOut>} An observable that emits the detail incident reason data.\n   */\n  getIncidentReason (id: Number): Observable<IncidentReasonOut> {\n    return this.http.get<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Creates a new incident reason.\n   *\n   * @param {IncidentReasonIn} body - The data for the new incident reason.\n   * @returns {Observable<IncidentReasonOut>} An observable the created incident reason detail.\n   */\n  postIncidentReason (body: IncidentReasonIn): Observable<IncidentReasonOut> {\n    return this.http.post<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Updates an existing incident reason.\n   *\n   * @param {number} id - The identifier of the incident reason record to update.\n   * @param {IncidentIn} body - The incident reason data to be updated.\n   * @returns {Observable<IncidentReasonOut>} An observable detail of the updated incident reason.\n   */\n  putIncidentReason (id: Number, body: IncidentReasonIn): Observable<IncidentReasonOut> {\n    return this.http.put<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Delete an existing incident reason.\n   *\n   * @param {number} id - The unique identifier of the incident reason to be deleted.\n   * @returns {Observable<IncidentReasonOut>} An observable that emits the result of the delete incident reason.\n   */\n  deleteIncidentReason (id: Number): Observable<IncidentReasonOut> {\n    return this.http.delete<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of incident reason complements based on query parameters.\n   *\n   * @param {QueryParams} params - Query parameters for filtering the incident reason complements.\n   * @returns {Observable<IncidentReasonComplementsOut>} An observable that emits the list of incident reason complements.\n   */\n  getIncidentReasonComplements (params: QueryParams): Observable<IncidentReasonComplementsOut> {\n    return this.http.get<ApiSuccess<IncidentReasonComplementsOut>>(`${this.url}/incident-reason-complements`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Creates a new incident reason complement.\n   *\n   * @param {IncidentReasonIn} body - The data for the new incident reason complement.\n   * @returns {Observable<IncidentReasonComplementOut>} An observable the created incident reason complement detail.\n   */\n  postIncidentReasonComplement (body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut> {\n    return this.http.post<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Updates an existing incident reason complement.\n   *\n   * @param {number} id - The identifier of the incident reason complement record to update.\n   * @param {IncidentIn} body - The incident reason complement data to be updated.\n   * @returns {Observable<IncidentReasonComplementOut>} An observable detail of the updated incident reason complement.\n   */\n  putIncidentReasonComplement (id: Number, body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut> {\n    return this.http.put<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements/${id}`,\n      body\n    ).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Delete an existing incident reason complement.\n   *\n   * @param {number} id - The unique identifier of the incident reason complement to be deleted.\n   * @returns {Observable<IncidentReasonComplementOut>} An observable that emits the result of the delete incident reason complement.\n   */\n  deleteIncidentReasonComplement (id: Number): Observable<IncidentReasonComplementOut> {\n    return this.http.delete<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements/${id}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Posts packages that are currently in stock.\n   *\n   * @param body - The input data containing package stock information\n   * @returns {Observable<PackagesInStockOut>} An Observable that emits the packages in stock output data\n   *\n   * @remarks\n   * This method sends a POST request to the `/packages/in-stock` endpoint and\n   * extracts the data property from the API success response.\n   */\n  postPackagesInStock (body: PackagesInStockIn): Observable<PackagesInStockOut> {\n    return this.http.post<ApiSuccess<PackagesInStockOut>>(`${this.url}/packages/in-stock`, body)\n      .pipe(map(({ data }) => data))\n  }\n}\n"]}

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

@@ -38,6 +38,34 @@ export class ApiReportsService {
         return this.http.get(`${this.url}/shipments-report`, { params })
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Retrieves the shipments landing report from the reports API.
+     *
+     * Sends a GET request to the `/shipments-landing-report` endpoint with the provided query parameters.
+     * The HTTP response is expected to be wrapped in an `ApiSuccess` envelope, from which the `data`
+     * payload is extracted and returned as the stream value.
+     *
+     * @param params - Query parameters used to filter or paginate the shipments landing report.
+     * @returns An observable that emits the parsed `ShipmentsLandingReportOut` data from the API response.
+     *
+     * @remarks
+     * - The underlying HTTP call uses `HttpClient.get` with `params` serialized as query string values.
+     * - The response is piped through `map` to unwrap `data` from `ApiSuccess<T>`.
+     * - Errors from the HTTP request are propagated through the observable stream.
+     *
+     * @example
+     * ```ts
+     * // Basic usage:
+     * service.getShipmentsLandingReport({ page: 1, perPage: 25 })
+     *   .subscribe(report => {
+     *     // handle ShipmentsLandingReportOut
+     *   });
+     * ```
+     */
+    getShipmentsLandingReport(params) {
+        return this.http.get(`${this.url}/shipments-landing-report`, { params })
+            .pipe(map(({ data }) => data));
+    }
     /**
      * Retrieves a report of external shipments based on the provided query parameters.
      *
@@ -125,4 +153,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-reports.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-reports.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpResponse } from '@angular/common/http'\nimport { Inject, Injectable } from '@angular/core'\nimport { map, Observable } from 'rxjs'\nimport { Environment } from '../ngx-services.models'\nimport {\n  CollectionPaymentsOut, ExternalShipmentsOut,\n  FileCheckOut, InvoicesOut, PartialWithdrawalsOut,\n  PromotionCodeDiscountsOut,\n  ShipmentsReportOut\n} from './models/api-reports.types'\nimport { ApiSuccess, QueryParams } from './models/api.models'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ApiReportsService {\n  constructor (\n    @Inject('env') private environments: Environment,\n    private http: HttpClient\n  ) { }\n\n  /**\n   * Retrieves the URL for the reports API from the environment configurations.\n   *\n   * @return {string} The URL of the reports API.\n   */\n  get url (): string {\n    return this.environments.apiReportsUrl ?? ''\n  }\n\n  /**\n   * Retrieves the list of collection payments\n   *\n   * @param {QueryParams} params - The query parameters used to fetch the collection payments.\n   * @return {Observable<CollectionPaymentsOut[]>} An observable that emits an array of collection payment.\n   */\n  getCollectionPayments (params: QueryParams): Observable<CollectionPaymentsOut> {\n    return this.http.get<ApiSuccess<CollectionPaymentsOut>>(`${this.url}/collection-payment`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Fetches shipment reports based on the provided query parameters.\n   *\n   * @param {QueryParams} params - The query parameters used to filter or define the shipment reports.\n   * @return {Observable<ShipmentsReportOut>} An observable emitting the shipment report data.\n   */\n  getShipmentsReport (params: QueryParams): Observable<ShipmentsReportOut> {\n    return this.http.get<ApiSuccess<ShipmentsReportOut>>(`${this.url}/shipments-report`, { params })\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a report of external shipments based on the provided query parameters.\n   *\n   * @param {QueryParams} params - An object representing the query parameters for filtering the external shipments report.\n   * @return {Observable<ExternalShipmentsOut>} An observable that emits the external shipments report data.\n   */\n  getExternalShipmentsReport (params: QueryParams): Observable<ExternalShipmentsOut> {\n    return this.http.get<ApiSuccess<ExternalShipmentsOut>>(`${this.url}/external-shipments-report`, { params })\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a report of promotion code discounts based on the provided query parameters.\n   *\n   * @param {QueryParams} params - An object representing the query parameters for filtering the promotion code discounts report.\n   * @return {Observable<PromotionCodeDiscountsOut>} An observable that emits the promotion code discounts report data.\n   */\n  getPromotionCodeDiscounts (params: QueryParams): Observable<PromotionCodeDiscountsOut> {\n    return this.http.get<ApiSuccess<PromotionCodeDiscountsOut>>(`${this.url}/promotion-code-discounts`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves the downloadable resource associated with the given transaction ID.\n   *\n   * @param {string} transactionId - The unique identifier of the transaction whose download is requested.\n   * @return {Observable<HttpResponse<ArrayBuffer>>} An observable that emits the HTTP response containing the resource in the form of an ArrayBuffer.\n   */\n  getDownload (transactionId: string): Observable<HttpResponse<ArrayBuffer>> {\n    return this.http.get(`${this.url}/download/${transactionId}`, {\n      observe: 'response',\n      responseType: 'arraybuffer'\n    })\n  }\n\n  /**\n   * Retrieves file check information for the specified transaction ID.\n   *\n   * @param {string} transactionId - The ID of the transaction for which the file check information is to be retrieved.\n   * @return {Observable<FileCheckOut>} An observable that emits the file check information associated with the given transaction ID.\n   */\n  getFileCheck (transactionId: string): Observable<FileCheckOut> {\n    return this.http.get<ApiSuccess<FileCheckOut>>(`${this.url}/file-check/${transactionId}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Deletes the file check associated with the provided transaction ID.\n   *\n   * @param {string} transactionId - The unique identifier of the transaction whose file check is to be deleted.\n   * @return {Observable<{}>} An observable emitting the response data after the deletion is processed.\n   */\n  deleteFileCheck (transactionId: string): Observable<{}> {\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/file-check/${transactionId}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves partial withdrawals based on the provided query parameters.\n   *\n   * @param {QueryParams} params - The parameters used to filter the list of partial withdrawals.\n   * @returns {Observable<PartialWithdrawalsOut>} An observable that emits the filtered list of partial withdrawals.\n   */\n  getPartialWithdrawals (params: QueryParams): Observable<PartialWithdrawalsOut> {\n    return this.http.get<ApiSuccess<PartialWithdrawalsOut>>(`${this.url}/partial-withdrawals`, {\n      params\n    })\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of invoices based on the provided query parameters.\n   *\n   * @param params - The query parameters used to filter the invoices.\n   * @returns An observable that emits the list of invoices.\n   */\n  getInvoices (params: QueryParams): Observable<InvoicesOut> {\n    return this.http.get<ApiSuccess<InvoicesOut>>(`${this.url}/invoices`, { params })\n      .pipe(map(({ data }) => data))\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-reports.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-reports.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpResponse } from '@angular/common/http'\nimport { Inject, Injectable } from '@angular/core'\nimport { map, Observable } from 'rxjs'\nimport { Environment } from '../ngx-services.models'\nimport {\n  CollectionPaymentsOut, ExternalShipmentsOut,\n  FileCheckOut, InvoicesOut, PartialWithdrawalsOut,\n  PromotionCodeDiscountsOut,\n  ShipmentsLandingReportOut,\n  ShipmentsReportOut\n} from './models/api-reports.types'\nimport { ApiSuccess, QueryParams } from './models/api.models'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ApiReportsService {\n  constructor (\n    @Inject('env') private environments: Environment,\n    private http: HttpClient\n  ) { }\n\n  /**\n   * Retrieves the URL for the reports API from the environment configurations.\n   *\n   * @return {string} The URL of the reports API.\n   */\n  get url (): string {\n    return this.environments.apiReportsUrl ?? ''\n  }\n\n  /**\n   * Retrieves the list of collection payments\n   *\n   * @param {QueryParams} params - The query parameters used to fetch the collection payments.\n   * @return {Observable<CollectionPaymentsOut[]>} An observable that emits an array of collection payment.\n   */\n  getCollectionPayments (params: QueryParams): Observable<CollectionPaymentsOut> {\n    return this.http.get<ApiSuccess<CollectionPaymentsOut>>(`${this.url}/collection-payment`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Fetches shipment reports based on the provided query parameters.\n   *\n   * @param {QueryParams} params - The query parameters used to filter or define the shipment reports.\n   * @return {Observable<ShipmentsReportOut>} An observable emitting the shipment report data.\n   */\n  getShipmentsReport (params: QueryParams): Observable<ShipmentsReportOut> {\n    return this.http.get<ApiSuccess<ShipmentsReportOut>>(`${this.url}/shipments-report`, { params })\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves the shipments landing report from the reports API.\n   *\n   * Sends a GET request to the `/shipments-landing-report` endpoint with the provided query parameters.\n   * The HTTP response is expected to be wrapped in an `ApiSuccess` envelope, from which the `data`\n   * payload is extracted and returned as the stream value.\n   *\n   * @param params - Query parameters used to filter or paginate the shipments landing report.\n   * @returns An observable that emits the parsed `ShipmentsLandingReportOut` data from the API response.\n   *\n   * @remarks\n   * - The underlying HTTP call uses `HttpClient.get` with `params` serialized as query string values.\n   * - The response is piped through `map` to unwrap `data` from `ApiSuccess<T>`.\n   * - Errors from the HTTP request are propagated through the observable stream.\n   *\n   * @example\n   * ```ts\n   * // Basic usage:\n   * service.getShipmentsLandingReport({ page: 1, perPage: 25 })\n   *   .subscribe(report => {\n   *     // handle ShipmentsLandingReportOut\n   *   });\n   * ```\n   */\n  getShipmentsLandingReport (params: QueryParams): Observable<ShipmentsLandingReportOut> {\n    return this.http.get<ApiSuccess<ShipmentsLandingReportOut>>(`${this.url}/shipments-landing-report`, { params })\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a report of external shipments based on the provided query parameters.\n   *\n   * @param {QueryParams} params - An object representing the query parameters for filtering the external shipments report.\n   * @return {Observable<ExternalShipmentsOut>} An observable that emits the external shipments report data.\n   */\n  getExternalShipmentsReport (params: QueryParams): Observable<ExternalShipmentsOut> {\n    return this.http.get<ApiSuccess<ExternalShipmentsOut>>(`${this.url}/external-shipments-report`, { params })\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a report of promotion code discounts based on the provided query parameters.\n   *\n   * @param {QueryParams} params - An object representing the query parameters for filtering the promotion code discounts report.\n   * @return {Observable<PromotionCodeDiscountsOut>} An observable that emits the promotion code discounts report data.\n   */\n  getPromotionCodeDiscounts (params: QueryParams): Observable<PromotionCodeDiscountsOut> {\n    return this.http.get<ApiSuccess<PromotionCodeDiscountsOut>>(`${this.url}/promotion-code-discounts`, {\n      params\n    }).pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves the downloadable resource associated with the given transaction ID.\n   *\n   * @param {string} transactionId - The unique identifier of the transaction whose download is requested.\n   * @return {Observable<HttpResponse<ArrayBuffer>>} An observable that emits the HTTP response containing the resource in the form of an ArrayBuffer.\n   */\n  getDownload (transactionId: string): Observable<HttpResponse<ArrayBuffer>> {\n    return this.http.get(`${this.url}/download/${transactionId}`, {\n      observe: 'response',\n      responseType: 'arraybuffer'\n    })\n  }\n\n  /**\n   * Retrieves file check information for the specified transaction ID.\n   *\n   * @param {string} transactionId - The ID of the transaction for which the file check information is to be retrieved.\n   * @return {Observable<FileCheckOut>} An observable that emits the file check information associated with the given transaction ID.\n   */\n  getFileCheck (transactionId: string): Observable<FileCheckOut> {\n    return this.http.get<ApiSuccess<FileCheckOut>>(`${this.url}/file-check/${transactionId}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Deletes the file check associated with the provided transaction ID.\n   *\n   * @param {string} transactionId - The unique identifier of the transaction whose file check is to be deleted.\n   * @return {Observable<{}>} An observable emitting the response data after the deletion is processed.\n   */\n  deleteFileCheck (transactionId: string): Observable<{}> {\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/file-check/${transactionId}`)\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves partial withdrawals based on the provided query parameters.\n   *\n   * @param {QueryParams} params - The parameters used to filter the list of partial withdrawals.\n   * @returns {Observable<PartialWithdrawalsOut>} An observable that emits the filtered list of partial withdrawals.\n   */\n  getPartialWithdrawals (params: QueryParams): Observable<PartialWithdrawalsOut> {\n    return this.http.get<ApiSuccess<PartialWithdrawalsOut>>(`${this.url}/partial-withdrawals`, {\n      params\n    })\n      .pipe(map(({ data }) => data))\n  }\n\n  /**\n   * Retrieves a list of invoices based on the provided query parameters.\n   *\n   * @param params - The query parameters used to filter the invoices.\n   * @returns An observable that emits the list of invoices.\n   */\n  getInvoices (params: QueryParams): Observable<InvoicesOut> {\n    return this.http.get<ApiSuccess<InvoicesOut>>(`${this.url}/invoices`, { params })\n      .pipe(map(({ data }) => data))\n  }\n}\n"]}

package/esm2022/lib/apis/models/api-inventories.types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/apis/models/api-reports.interfaces.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-reports.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-reports.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { OperationType } from './api-catalog.interfaces'\nimport { ActiveLessLaravelModel, ActiveLessSymfonyModel, ApiModel, LaravelModel, Translations } from './api.models'\n\nexport interface CollectionPayment extends LaravelModel {\n  _id: number,\n  country_code: string,\n  country_id: number,\n  country_name: string,\n  company_id: number,\n  company_name: string,\n  company_country_id: number,\n  installation_id: number,\n  installation_number: number,\n  location_facility_code: string,\n  location_id: number,\n  location_location_code: string,\n  location_name: string,\n  user_id: number,\n  user_username: string,\n  document_type_id: number,\n  document_type: DocumentTypeReports,\n  document_category_id: number,\n  document_category: DocumentCategoryReports,\n  receipt_number: string,\n  customer_name: string,\n  account: string,\n  amount: number,\n  currency_id: number,\n  currency_code: string\n  operation_type_id: number\n  operation_type: OperationType\n}\n\nexport interface DocumentTypeReports extends LaravelModel {\n  _id: number,\n  name: string,\n  code: string,\n  movement_type: number,\n  local_code: string,\n  translations: Translations\n}\n\nexport interface DocumentCategoryReports extends LaravelModel {\n  _id: number,\n  name: string,\n  is_electronic: true,\n  taxable: number,\n  created_at: string,\n  updated_at: string,\n  translations: Translations\n}\n\nexport interface ShipmentReports {\n  authorization_numbers: string[]\n  commercial_invoice: boolean\n  company_name: string\n  country_id: number\n  country_name: string\n  currency_code: string\n  customer_identification_number: string | null\n  customer_identification_type_id: number | null\n  document_id: number\n  id: number\n  installation_id: number\n  installation_number: number\n  invoice_document_id: number | null\n  is_document: boolean\n  is_manual: boolean\n  itn_number: string | null\n  location_id: number\n  location_name: string\n  price_override_approver_name: string | null\n  price_override_reason_name: string | null\n  product_subtotal: number\n  product_tax: number\n  question_description: string | null\n  receiver_company_name: string\n  receiver_full_name: string\n  send_to_api_inventories: boolean\n  shipment_id: number\n  shipment_pieces_tracking_numbers: string[]\n  shipment_status_code: string\n  shipment_status_description: string\n  shipment_status_id: number\n  shipment_status_translations: Translations\n  shipment_tags: ShipmentTag[]\n  shipment_tracking_number: string\n  shipment_type: string\n  shipment_value: string\n  shipper_account: string\n  shipper_address_line1: string\n  shipper_address_line2: string | null\n  shipper_address_line3: string | null\n  shipper_city_name: string\n  shipper_company_name: string\n  shipper_email: string\n  shipper_full_name: string\n  shipper_full_phone_number: string\n  shipper_identification_number: string | null\n  shipper_phone_number: string\n  shipper_postal_code: string\n  shipper_state_name: string | null\n  subtotal: number\n  tax: number\n  total: number\n  tracking: string | null\n  updated_at: string\n  user_id: number\n  user_username: string\n  additional_documents: {\n    country_id: number\n    include_indemnity_letter: boolean\n    shipment_content_type_id: number\n    shipment_scope_id: number\n  }\n  document_payments: {\n    payment: {\n      countryPaymentType: {\n        code: string\n      }\n    }\n  }[]\n}\n\nexport interface ShipmentTag extends ActiveLessSymfonyModel {\n  name: string\n  code: string\n  translations: Translations\n}\n\nexport interface ReportExternalShipment extends ActiveLessLaravelModel {\n  account_number: string\n  collection_date: string\n  document_id: number | null\n  document_number: string | null\n  external_shipment_addresses: ReportExternalShipmentAddress[]\n  external_shipment_file_id: number\n  external_shipment_status_id: number\n  external_shipment_status_name: string\n  external_shipment_status_translations: Translations\n  installation_id: number\n  subtotal: number\n  tax: number\n  total: number\n  tracking_number: string\n  user_id: number\n}\n\nexport interface ReportExternalShipmentAddress extends ApiModel {\n  address_line_1: string\n  address_line_2: string\n  city_name: string\n  company_name: string\n  country_id: number\n  email: string\n  full_name: string\n  identification_number: string | null\n  identification_type_id: number | null\n  phone_number: string\n  postal_code: string\n  role_type: string\n  service_area_code: string\n}\n\nexport interface PromotionCodeDiscount extends ApiModel {\n  country_id: number\n  company_country_id: number\n  location_id: number\n  installation_id: number\n  user_id: number\n  user_username: string\n  updated_at: Date | string\n  tracking_number: string\n  product_id: number\n  product_global_code: string\n  product_global_name: string\n  origin_facility_code: string\n  destination_facility_code: string\n  origin_company_name: string\n  origin_full_name: string\n  promotion_code: string\n  discount_percentage: number\n  product_subtotals: ProductSubtotal[]\n}\n\nexport interface ProductSubtotal {\n  country_reference_currency_id: number\n  currency_id: number\n  currency_code: string\n  value: number\n  shipment_total: number\n  discount_amount: number\n}\n\nexport interface WithdrawalAmount {\n  country_reference_currency_id: number\n  currency_id: number\n  currency_code: string\n  value: number | null\n}\n\nexport interface PartialWithdrawal extends ActiveLessLaravelModel {\n  country_id: number\n  company_country_id: number\n  location_id: number\n  installation_id: number\n  opening_user_id: number\n  opening_user_username: string\n  opening_user_name: string\n  opening_reference_user_id: number\n  opening_reference_user_username: string\n  opening_reference_user_name: string\n  receipt_number: string\n  amounts: WithdrawalAmount[]\n}\n\nexport interface Invoice extends ActiveLessLaravelModel {\n  complete_document_number: string\n  tracking_numbers: string[]\n  local_currency_total_amount: number\n  identification_type_name: string\n  identification_number: string\n  customer_full_name: string\n  customer_address: string\n  customer_email: string\n  customer_extra_fields: {\n    field: string\n    value: string\n  }[]\n  document_type_name: string\n  document_type_name_ES: string\n  document_type_name_EN: string\n  document_category_name: string\n  document_category_name_ES: string\n  document_category_name_EN: string\n  document_status_id: number\n  document_status_code: string\n  transaction_type: string\n  installation_id: number\n  location_id: number\n  company_country_id: number\n  country_id: number\n  customer_phone_code: string\n  customer_phone_number: string\n  customer_city_name: string\n  customer_county_name: string\n  shipment_id: number\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-reports.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-reports.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { OperationType } from './api-catalog.interfaces'\nimport { ActiveLessLaravelModel, ActiveLessSymfonyModel, ApiModel, LaravelModel, Translations } from './api.models'\n\nexport interface CollectionPayment extends LaravelModel {\n  _id: number,\n  country_code: string,\n  country_id: number,\n  country_name: string,\n  company_id: number,\n  company_name: string,\n  company_country_id: number,\n  installation_id: number,\n  installation_number: number,\n  location_facility_code: string,\n  location_id: number,\n  location_location_code: string,\n  location_name: string,\n  user_id: number,\n  user_username: string,\n  document_type_id: number,\n  document_type: DocumentTypeReports,\n  document_category_id: number,\n  document_category: DocumentCategoryReports,\n  receipt_number: string,\n  customer_name: string,\n  account: string,\n  amount: number,\n  currency_id: number,\n  currency_code: string\n  operation_type_id: number\n  operation_type: OperationType\n}\n\nexport interface DocumentTypeReports extends LaravelModel {\n  _id: number,\n  name: string,\n  code: string,\n  movement_type: number,\n  local_code: string,\n  translations: Translations\n}\n\nexport interface DocumentCategoryReports extends LaravelModel {\n  _id: number,\n  name: string,\n  is_electronic: true,\n  taxable: number,\n  created_at: string,\n  updated_at: string,\n  translations: Translations\n}\n\nexport interface ShipmentReports {\n  authorization_numbers: string[]\n  commercial_invoice: boolean\n  company_name: string\n  country_id: number\n  country_name: string\n  currency_code: string\n  customer_identification_number: string | null\n  customer_identification_type_id: number | null\n  document_id: number\n  id: number\n  installation_id: number\n  installation_number: number\n  invoice_document_id: number | null\n  is_document: boolean\n  is_manual: boolean\n  itn_number: string | null\n  location_id: number\n  location_name: string\n  price_override_approver_name: string | null\n  price_override_reason_name: string | null\n  product_subtotal: number\n  product_tax: number\n  question_description: string | null\n  receiver_company_name: string\n  receiver_full_name: string\n  send_to_api_inventories: boolean\n  shipment_id: number\n  shipment_pieces_tracking_numbers: string[]\n  shipment_status_code: string\n  shipment_status_description: string\n  shipment_status_id: number\n  shipment_status_translations: Translations\n  shipment_tags: ShipmentTag[]\n  shipment_tracking_number: string\n  shipment_type: string\n  shipment_value: string\n  shipper_account: string\n  shipper_address_line1: string\n  shipper_address_line2: string | null\n  shipper_address_line3: string | null\n  shipper_city_name: string\n  shipper_company_name: string\n  shipper_email: string\n  shipper_full_name: string\n  shipper_full_phone_number: string\n  shipper_identification_number: string | null\n  shipper_phone_number: string\n  shipper_postal_code: string\n  shipper_state_name: string | null\n  subtotal: number\n  tax: number\n  total: number\n  tracking: string | null\n  updated_at: string\n  user_id: number\n  user_username: string\n  additional_documents: {\n    country_id: number\n    include_indemnity_letter: boolean\n    shipment_content_type_id: number\n    shipment_scope_id: number\n  }\n  document_payments: {\n    payment: {\n      countryPaymentType: {\n        code: string\n      }\n    }\n  }[]\n}\n\nexport interface ShipmentLandingReport extends ActiveLessLaravelModel {\n  authorization_numbers: string[]\n  commercial_invoice: boolean\n  company_id: number\n  company_name: string\n  country_id: number\n  currency_code: string | null\n  document_id: number\n  hasCreditCardPayment: boolean\n  installation_id: number\n  installation_number: number\n  invoice_document_id: number | null\n  is_document: boolean\n  is_manual: boolean\n  itn_number: string\n  location_code: string\n  location_facility_code: string\n  location_id: number\n  location_name: string\n  price_override_approver_name: string\n  price_override_reason_name: string\n  product_global_name: string\n  product_local_name: string\n  question_description: string | null\n  receiver_address_line1: string\n  receiver_city_name: string\n  receiver_company_name: string\n  receiver_country_name: string\n  receiver_full_name: string\n  receiver_postal_code: string\n  receiver_state_name: string\n  send_to_api_inventories: boolean\n  shipment_description: string\n  shipment_group_id: number\n  shipment_group_name: string\n  shipment_pieces_tracking_numbers: string[]\n  shipment_status_code: string\n  shipment_status_id: number\n  shipment_status_name_EN: string\n  shipment_status_name_ES: string\n  shipment_status_name_FR: string\n  shipment_status_name_PT: string\n  shipment_tags: ShipmentTag[]\n  shipment_tracking_number: string\n  shipment_type: string\n  shipment_value: string\n  shipper_account: string\n  shipper_address_line1: string\n  shipper_address_line2: string\n  shipper_address_line3: string\n  shipper_city_name: string\n  shipper_company_name: string\n  shipper_email: string\n  shipper_full_name: string\n  shipper_full_phone_number: string\n  shipper_identification_number: string\n  shipper_phone_number: string\n  shipper_postal_code: string\n  shipper_state_name: string\n  tracking: string | null\n  user_id: number\n  user_username: string\n  additional_documents: {\n    country_id: number\n    include_indemnity_letter: boolean\n    shipment_content_type_id: number\n    shipment_scope_id: number\n  }\n}\n\nexport interface ShipmentTag extends ActiveLessSymfonyModel {\n  name: string\n  code: string\n  translations: Translations\n}\n\nexport interface ReportExternalShipment extends ActiveLessLaravelModel {\n  account_number: string\n  collection_date: string\n  document_id: number | null\n  document_number: string | null\n  external_shipment_addresses: ReportExternalShipmentAddress[]\n  external_shipment_file_id: number\n  external_shipment_status_id: number\n  external_shipment_status_name: string\n  external_shipment_status_translations: Translations\n  installation_id: number\n  subtotal: number\n  tax: number\n  total: number\n  tracking_number: string\n  user_id: number\n}\n\nexport interface ReportExternalShipmentAddress extends ApiModel {\n  address_line_1: string\n  address_line_2: string\n  city_name: string\n  company_name: string\n  country_id: number\n  email: string\n  full_name: string\n  identification_number: string | null\n  identification_type_id: number | null\n  phone_number: string\n  postal_code: string\n  role_type: string\n  service_area_code: string\n}\n\nexport interface PromotionCodeDiscount extends ApiModel {\n  country_id: number\n  company_country_id: number\n  location_id: number\n  installation_id: number\n  user_id: number\n  user_username: string\n  updated_at: Date | string\n  tracking_number: string\n  product_id: number\n  product_global_code: string\n  product_global_name: string\n  origin_facility_code: string\n  destination_facility_code: string\n  origin_company_name: string\n  origin_full_name: string\n  promotion_code: string\n  discount_percentage: number\n  product_subtotals: ProductSubtotal[]\n}\n\nexport interface ProductSubtotal {\n  country_reference_currency_id: number\n  currency_id: number\n  currency_code: string\n  value: number\n  shipment_total: number\n  discount_amount: number\n}\n\nexport interface WithdrawalAmount {\n  country_reference_currency_id: number\n  currency_id: number\n  currency_code: string\n  value: number | null\n}\n\nexport interface PartialWithdrawal extends ActiveLessLaravelModel {\n  country_id: number\n  company_country_id: number\n  location_id: number\n  installation_id: number\n  opening_user_id: number\n  opening_user_username: string\n  opening_user_name: string\n  opening_reference_user_id: number\n  opening_reference_user_username: string\n  opening_reference_user_name: string\n  receipt_number: string\n  amounts: WithdrawalAmount[]\n}\n\nexport interface Invoice extends ActiveLessLaravelModel {\n  complete_document_number: string\n  tracking_numbers: string[]\n  local_currency_total_amount: number\n  identification_type_name: string\n  identification_number: string\n  customer_full_name: string\n  customer_address: string\n  customer_email: string\n  customer_extra_fields: {\n    field: string\n    value: string\n  }[]\n  document_type_name: string\n  document_type_name_ES: string\n  document_type_name_EN: string\n  document_category_name: string\n  document_category_name_ES: string\n  document_category_name_EN: string\n  document_status_id: number\n  document_status_code: string\n  transaction_type: string\n  installation_id: number\n  location_id: number\n  company_country_id: number\n  country_id: number\n  customer_phone_code: string\n  customer_phone_number: string\n  customer_city_name: string\n  customer_county_name: string\n  shipment_id: number\n}\n"]}

package/esm2022/lib/apis/models/api-reports.types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -28,7 +28,6 @@ export * from './lib/apis/api-services.service';
 export * from './lib/apis/api-shipments.service';
 export * from './lib/apis/api-supplies.service';
 // api models
-export * from './lib/apis/models/api-billing.models';
 export * from './lib/apis/models/api-billing-do.interfaces';
 export * from './lib/apis/models/api-billing-do.types';
 export * from './lib/apis/models/api-billing-mx.interfaces';
@@ -37,6 +36,7 @@ export * from './lib/apis/models/api-billing-pa.interfaces';
 export * from './lib/apis/models/api-billing-pa.types';
 export * from './lib/apis/models/api-billing-sv.interfaces';
 export * from './lib/apis/models/api-billing-sv.types';
+export * from './lib/apis/models/api-billing.models';
 export * from './lib/apis/models/api-cash-operations.interfaces';
 export * from './lib/apis/models/api-cash-operations.types';
 export * from './lib/apis/models/api-catalog.enum';
@@ -50,11 +50,11 @@ export * from './lib/apis/models/api-customs.interfaces';
 export * from './lib/apis/models/api-customs.types';
 export * from './lib/apis/models/api-discounts.interfaces';
 export * from './lib/apis/models/api-discounts.types';
+export * from './lib/apis/models/api-e-tools-auto-billing.interfaces';
+export * from './lib/apis/models/api-e-tools-auto-billing.types';
 export * from './lib/apis/models/api-events.enum';
 export * from './lib/apis/models/api-events.interfaces';
 export * from './lib/apis/models/api-events.types';
-export * from './lib/apis/models/api-e-tools-auto-billing.interfaces';
-export * from './lib/apis/models/api-e-tools-auto-billing.types';
 export * from './lib/apis/models/api-external-pickups.types';
 export * from './lib/apis/models/api-inventories.enum';
 export * from './lib/apis/models/api-inventories.interfaces';
@@ -66,6 +66,7 @@ export * from './lib/apis/models/api-notifications.types';
 export * from './lib/apis/models/api-open-items.interfaces';
 export * from './lib/apis/models/api-open-items.types';
 export * from './lib/apis/models/api-reports.interfaces';
+export * from './lib/apis/models/api-reports.types';
 export * from './lib/apis/models/api-security.interfaces';
 export * from './lib/apis/models/api-security.types';
 export * from './lib/apis/models/api-services.interfaces';
@@ -86,4 +87,4 @@ export * from './lib/interceptors/http-caching.interceptor';
 // helpers
 export * from './lib/helpers/http';
 export * from './lib/helpers/files';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../../projects/experteam-mx/ngx-services/src/public-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,2BAA2B,CAAA;AACzC,cAAc,2BAA2B,CAAA;AAEzC,eAAe;AACf,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,oCAAoC,CAAA;AAClD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,kCAAkC,CAAA;AAChD,cAAc,+BAA+B,CAAA;AAC7C,cAAc,6CAA6C,CAAA;AAC3D,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAE/C,aAAa;AACb,cAAc,sCAAsC,CAAA;AACpD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,kDAAkD,CAAA;AAChE,cAAc,6CAA6C,CAAA;AAC3D,cAAc,oCAAoC,CAAA;AAClD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,mCAAmC,CAAA;AACjD,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,uDAAuD,CAAA;AACrE,cAAc,kDAAkD,CAAA;AAChE,cAAc,8CAA8C,CAAA;AAC5D,cAAc,wCAAwC,CAAA;AACtD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,gDAAgD,CAAA;AAC9D,cAAc,2CAA2C,CAAA;AACzD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,0CAA0C,CAAA;AACxD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,8BAA8B,CAAA;AAE5C,aAAa;AACb,cAAc,sCAAsC,CAAA;AAEpD,SAAS;AACT,cAAc,6BAA6B,CAAA;AAE3C,eAAe;AACf,cAAc,4CAA4C,CAAA;AAC1D,cAAc,0CAA0C,CAAA;AACxD,cAAc,6CAA6C,CAAA;AAE3D,UAAU;AACV,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA","sourcesContent":["/*\n * Public API Surface of ngx-services\n */\nexport * from './lib/ngx-services.models'\nexport * from './lib/ngx-services.module'\n\n// api services\nexport * from './lib/apis/api-billing-do.service'\nexport * from './lib/apis/api-billing-gt.service'\nexport * from './lib/apis/api-billing-mx.service'\nexport * from './lib/apis/api-billing-pa.service'\nexport * from './lib/apis/api-billing-sv.service'\nexport * from './lib/apis/api-cash-operations.service'\nexport * from './lib/apis/api-catalogs.service'\nexport * from './lib/apis/api-companies.service'\nexport * from './lib/apis/api-composition.service'\nexport * from './lib/apis/api-customs.service'\nexport * from './lib/apis/api-discounts.service'\nexport * from './lib/apis/api-events.service'\nexport * from './lib/apis/api-e-tools-auto-billing.service'\nexport * from './lib/apis/api-external-pickups.service'\nexport * from './lib/apis/api-inventories.service'\nexport * from './lib/apis/api-invoices.service'\nexport * from './lib/apis/api-notifications.service'\nexport * from './lib/apis/api-open-items.service'\nexport * from './lib/apis/api-reports.service'\nexport * from './lib/apis/api-security.service'\nexport * from './lib/apis/api-services.service'\nexport * from './lib/apis/api-shipments.service'\nexport * from './lib/apis/api-supplies.service'\n\n// api models\nexport * from './lib/apis/models/api-billing.models'\nexport * from './lib/apis/models/api-billing-do.interfaces'\nexport * from './lib/apis/models/api-billing-do.types'\nexport * from './lib/apis/models/api-billing-mx.interfaces'\nexport * from './lib/apis/models/api-billing-mx.types'\nexport * from './lib/apis/models/api-billing-pa.interfaces'\nexport * from './lib/apis/models/api-billing-pa.types'\nexport * from './lib/apis/models/api-billing-sv.interfaces'\nexport * from './lib/apis/models/api-billing-sv.types'\nexport * from './lib/apis/models/api-cash-operations.interfaces'\nexport * from './lib/apis/models/api-cash-operations.types'\nexport * from './lib/apis/models/api-catalog.enum'\nexport * from './lib/apis/models/api-catalog.interfaces'\nexport * from './lib/apis/models/api-catalog.types'\nexport * from './lib/apis/models/api-companies.interfaces'\nexport * from './lib/apis/models/api-companies.types'\nexport * from './lib/apis/models/api-composition.interfaces'\nexport * from './lib/apis/models/api-composition.types'\nexport * from './lib/apis/models/api-customs.interfaces'\nexport * from './lib/apis/models/api-customs.types'\nexport * from './lib/apis/models/api-discounts.interfaces'\nexport * from './lib/apis/models/api-discounts.types'\nexport * from './lib/apis/models/api-events.enum'\nexport * from './lib/apis/models/api-events.interfaces'\nexport * from './lib/apis/models/api-events.types'\nexport * from './lib/apis/models/api-e-tools-auto-billing.interfaces'\nexport * from './lib/apis/models/api-e-tools-auto-billing.types'\nexport * from './lib/apis/models/api-external-pickups.types'\nexport * from './lib/apis/models/api-inventories.enum'\nexport * from './lib/apis/models/api-inventories.interfaces'\nexport * from './lib/apis/models/api-inventories.types'\nexport * from './lib/apis/models/api-invoices.interfaces'\nexport * from './lib/apis/models/api-invoices.types'\nexport * from './lib/apis/models/api-notifications.interfaces'\nexport * from './lib/apis/models/api-notifications.types'\nexport * from './lib/apis/models/api-open-items.interfaces'\nexport * from './lib/apis/models/api-open-items.types'\nexport * from './lib/apis/models/api-reports.interfaces'\nexport * from './lib/apis/models/api-security.interfaces'\nexport * from './lib/apis/models/api-security.types'\nexport * from './lib/apis/models/api-services.interfaces'\nexport * from './lib/apis/models/api-services.types'\nexport * from './lib/apis/models/api-shipments.interfaces'\nexport * from './lib/apis/models/api-shipments.types'\nexport * from './lib/apis/models/api-supplies.interfaces'\nexport * from './lib/apis/models/api-supplies.types'\nexport * from './lib/apis/models/api.models'\n\n// websockets\nexport * from './lib/websockets/web-sockets.service'\n\n// cypher\nexport * from './lib/cypher/crypto.service'\n\n// interceptors\nexport * from './lib/interceptors/api-headers.interceptor'\nexport * from './lib/interceptors/api-token.interceptor'\nexport * from './lib/interceptors/http-caching.interceptor'\n\n// helpers\nexport * from './lib/helpers/http'\nexport * from './lib/helpers/files'\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../../projects/experteam-mx/ngx-services/src/public-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,2BAA2B,CAAA;AACzC,cAAc,2BAA2B,CAAA;AAEzC,eAAe;AACf,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,oCAAoC,CAAA;AAClD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,kCAAkC,CAAA;AAChD,cAAc,+BAA+B,CAAA;AAC7C,cAAc,6CAA6C,CAAA;AAC3D,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAE/C,aAAa;AACb,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,sCAAsC,CAAA;AACpD,cAAc,kDAAkD,CAAA;AAChE,cAAc,6CAA6C,CAAA;AAC3D,cAAc,oCAAoC,CAAA;AAClD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,uDAAuD,CAAA;AACrE,cAAc,kDAAkD,CAAA;AAChE,cAAc,mCAAmC,CAAA;AACjD,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,wCAAwC,CAAA;AACtD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,gDAAgD,CAAA;AAC9D,cAAc,2CAA2C,CAAA;AACzD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,8BAA8B,CAAA;AAE5C,aAAa;AACb,cAAc,sCAAsC,CAAA;AAEpD,SAAS;AACT,cAAc,6BAA6B,CAAA;AAE3C,eAAe;AACf,cAAc,4CAA4C,CAAA;AAC1D,cAAc,0CAA0C,CAAA;AACxD,cAAc,6CAA6C,CAAA;AAE3D,UAAU;AACV,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA","sourcesContent":["/*\n * Public API Surface of ngx-services\n */\nexport * from './lib/ngx-services.models'\nexport * from './lib/ngx-services.module'\n\n// api services\nexport * from './lib/apis/api-billing-do.service'\nexport * from './lib/apis/api-billing-gt.service'\nexport * from './lib/apis/api-billing-mx.service'\nexport * from './lib/apis/api-billing-pa.service'\nexport * from './lib/apis/api-billing-sv.service'\nexport * from './lib/apis/api-cash-operations.service'\nexport * from './lib/apis/api-catalogs.service'\nexport * from './lib/apis/api-companies.service'\nexport * from './lib/apis/api-composition.service'\nexport * from './lib/apis/api-customs.service'\nexport * from './lib/apis/api-discounts.service'\nexport * from './lib/apis/api-events.service'\nexport * from './lib/apis/api-e-tools-auto-billing.service'\nexport * from './lib/apis/api-external-pickups.service'\nexport * from './lib/apis/api-inventories.service'\nexport * from './lib/apis/api-invoices.service'\nexport * from './lib/apis/api-notifications.service'\nexport * from './lib/apis/api-open-items.service'\nexport * from './lib/apis/api-reports.service'\nexport * from './lib/apis/api-security.service'\nexport * from './lib/apis/api-services.service'\nexport * from './lib/apis/api-shipments.service'\nexport * from './lib/apis/api-supplies.service'\n\n// api models\nexport * from './lib/apis/models/api-billing-do.interfaces'\nexport * from './lib/apis/models/api-billing-do.types'\nexport * from './lib/apis/models/api-billing-mx.interfaces'\nexport * from './lib/apis/models/api-billing-mx.types'\nexport * from './lib/apis/models/api-billing-pa.interfaces'\nexport * from './lib/apis/models/api-billing-pa.types'\nexport * from './lib/apis/models/api-billing-sv.interfaces'\nexport * from './lib/apis/models/api-billing-sv.types'\nexport * from './lib/apis/models/api-billing.models'\nexport * from './lib/apis/models/api-cash-operations.interfaces'\nexport * from './lib/apis/models/api-cash-operations.types'\nexport * from './lib/apis/models/api-catalog.enum'\nexport * from './lib/apis/models/api-catalog.interfaces'\nexport * from './lib/apis/models/api-catalog.types'\nexport * from './lib/apis/models/api-companies.interfaces'\nexport * from './lib/apis/models/api-companies.types'\nexport * from './lib/apis/models/api-composition.interfaces'\nexport * from './lib/apis/models/api-composition.types'\nexport * from './lib/apis/models/api-customs.interfaces'\nexport * from './lib/apis/models/api-customs.types'\nexport * from './lib/apis/models/api-discounts.interfaces'\nexport * from './lib/apis/models/api-discounts.types'\nexport * from './lib/apis/models/api-e-tools-auto-billing.interfaces'\nexport * from './lib/apis/models/api-e-tools-auto-billing.types'\nexport * from './lib/apis/models/api-events.enum'\nexport * from './lib/apis/models/api-events.interfaces'\nexport * from './lib/apis/models/api-events.types'\nexport * from './lib/apis/models/api-external-pickups.types'\nexport * from './lib/apis/models/api-inventories.enum'\nexport * from './lib/apis/models/api-inventories.interfaces'\nexport * from './lib/apis/models/api-inventories.types'\nexport * from './lib/apis/models/api-invoices.interfaces'\nexport * from './lib/apis/models/api-invoices.types'\nexport * from './lib/apis/models/api-notifications.interfaces'\nexport * from './lib/apis/models/api-notifications.types'\nexport * from './lib/apis/models/api-open-items.interfaces'\nexport * from './lib/apis/models/api-open-items.types'\nexport * from './lib/apis/models/api-reports.interfaces'\nexport * from './lib/apis/models/api-reports.types'\nexport * from './lib/apis/models/api-security.interfaces'\nexport * from './lib/apis/models/api-security.types'\nexport * from './lib/apis/models/api-services.interfaces'\nexport * from './lib/apis/models/api-services.types'\nexport * from './lib/apis/models/api-shipments.interfaces'\nexport * from './lib/apis/models/api-shipments.types'\nexport * from './lib/apis/models/api-supplies.interfaces'\nexport * from './lib/apis/models/api-supplies.types'\nexport * from './lib/apis/models/api.models'\n\n// websockets\nexport * from './lib/websockets/web-sockets.service'\n\n// cypher\nexport * from './lib/cypher/crypto.service'\n\n// interceptors\nexport * from './lib/interceptors/api-headers.interceptor'\nexport * from './lib/interceptors/api-token.interceptor'\nexport * from './lib/interceptors/http-caching.interceptor'\n\n// helpers\nexport * from './lib/helpers/http'\nexport * from './lib/helpers/files'\n"]}

package/fesm2022/experteam-mx-ngx-services.mjs

@@ -2904,6 +2904,20 @@ class ApiInventoriesService {
         return this.http.delete(`${this.url}/incident-reason-complements/${id}`)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Posts packages that are currently in stock.
+     *
+     * @param body - The input data containing package stock information
+     * @returns {Observable<PackagesInStockOut>} An Observable that emits the packages in stock output data
+     *
+     * @remarks
+     * This method sends a POST request to the `/packages/in-stock` endpoint and
+     * extracts the data property from the API success response.
+     */
+    postPackagesInStock(body) {
+        return this.http.post(`${this.url}/packages/in-stock`, body)
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInventoriesService, 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: ApiInventoriesService, providedIn: 'root' });
 }
@@ -3505,6 +3519,34 @@ class ApiReportsService {
         return this.http.get(`${this.url}/shipments-report`, { params })
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Retrieves the shipments landing report from the reports API.
+     *
+     * Sends a GET request to the `/shipments-landing-report` endpoint with the provided query parameters.
+     * The HTTP response is expected to be wrapped in an `ApiSuccess` envelope, from which the `data`
+     * payload is extracted and returned as the stream value.
+     *
+     * @param params - Query parameters used to filter or paginate the shipments landing report.
+     * @returns An observable that emits the parsed `ShipmentsLandingReportOut` data from the API response.
+     *
+     * @remarks
+     * - The underlying HTTP call uses `HttpClient.get` with `params` serialized as query string values.
+     * - The response is piped through `map` to unwrap `data` from `ApiSuccess<T>`.
+     * - Errors from the HTTP request are propagated through the observable stream.
+     *
+     * @example
+     * ```ts
+     * // Basic usage:
+     * service.getShipmentsLandingReport({ page: 1, perPage: 25 })
+     *   .subscribe(report => {
+     *     // handle ShipmentsLandingReportOut
+     *   });
+     * ```
+     */
+    getShipmentsLandingReport(params) {
+        return this.http.get(`${this.url}/shipments-landing-report`, { params })
+            .pipe(map(({ data }) => data));
+    }
     /**
      * Retrieves a report of external shipments based on the provided query parameters.
      *