@experteam-mx/ngx-services 18.9.14 → 18.9.15

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":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAIlD,OAAO,EAAE,GAAG,EAAc,MAAM,MAAM,CAAA;;;AAMtC,MAAM,OAAO,qBAAqB;IAEP;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,iBAAiB,IAAI,EAAE,CAAA;IAClD,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAE,MAAmB;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA6B,GAAG,IAAI,CAAC,GAAG,cAAc,EAAE;YAC1E,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAE,MAAmB;QAC5C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAwC,GAAG,IAAI,CAAC,GAAG,2BAA2B,EAAE;YAClG,MAAM;SACP,CAAC,CAAC,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;YACtE,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAE,EAAU;QACrB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA0B,GAAG,IAAI,CAAC,GAAG,cAAc,EAAE,EAAE,CAAC;aACzE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAE,IAAgB;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA0B,GAAG,IAAI,CAAC,GAAG,YAAY,EACpE,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAE,EAAU,EAAE,IAAgB;QACvC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA0B,GAAG,IAAI,CAAC,GAAG,cAAc,EAAE,EAAE,EACzE,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAE,EAAU;QACxB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAA0B,GAAG,IAAI,CAAC,GAAG,cAAc,EAAE,EAAE,CAAC;aAC5E,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,kBAAkB,CAAE,MAAmB;QACrC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAiC,GAAG,IAAI,CAAC,GAAG,mBAAmB,EAAE;YACnF,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAE,EAAU;QAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAgC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE,EAAE,CAAC;aACtF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,kBAAkB,CAAE,IAAsB;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAgC,GAAG,IAAI,CAAC,GAAG,mBAAmB,EACjF,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;;OAMG;IACH,iBAAiB,CAAE,EAAU,EAAE,IAAsB;QACnD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAgC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE,EAAE,EACtF,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;OAKG;IACH,oBAAoB,CAAE,EAAU;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAgC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE,EAAE,CAAC;aACzF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,4BAA4B,CAAE,MAAmB;QAC/C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA2C,GAAG,IAAI,CAAC,GAAG,8BAA8B,EAAE;YACxG,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,4BAA4B,CAAE,IAAgC;QAC5D,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA0C,GAAG,IAAI,CAAC,GAAG,8BAA8B,EACtG,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;;OAMG;IACH,2BAA2B,CAAE,EAAU,EAAE,IAAgC;QACvE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA0C,GAAG,IAAI,CAAC,GAAG,gCAAgC,EAAE,EAAE,EAC3G,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;OAKG;IACH,8BAA8B,CAAE,EAAU;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAA0C,GAAG,IAAI,CAAC,GAAG,gCAAgC,EAAE,EAAE,CAAC;aAC9G,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;;;;;OASG;IACH,mBAAmB,CAAE,IAAuB;QAC1C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiC,GAAG,IAAI,CAAC,GAAG,oBAAoB,EAAE,IAAI,CAAC;aACzF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;wGA1NU,qBAAqB,kBAEtB,KAAK;4GAFJ,qBAAqB,cAFpB,MAAM;;4FAEP,qBAAqB;kBAHjC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAGI,MAAM;2BAAC,KAAK","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-quote.service.mjs

@@ -0,0 +1,87 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Service to manage quote-related events.
+ *
+ * This service provides methods to retrieve, create, and get event types
+ * related to quote processes.
+ */
+export class ApiQuoteService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Base URL for the Quotes API.
+     */
+    get url() {
+        return this.environments.apiQuotesUrl ?? '';
+    }
+    /**
+     * Retrieves all registered events for a specific quote.
+     *
+     * @param id - Quote identifier.
+     * @param params - Optional query parameters such as pagination or filtering.
+     * @returns Observable containing the list of quote events.
+     *
+     * @example
+     * ```ts
+     * this.apiQuoteService.getQuoteEvents(10, { page: 1 })
+     *   .subscribe((events) => console.log(events))
+     * ```
+     */
+    getQuoteEvents(id, params) {
+        return this.http.get(`${this.url}/quotes/${id}/quote-events`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Registers a new event related to a specific quote.
+     *
+     * @param id - Quote identifier.
+     * @param body - Event payload to be created.
+     * @returns Observable containing the newly created event.
+     *
+     * @example
+     * ```ts
+     * const event: QuoteEventIn = { code: 'WON', note: 'Client approved' }
+     * this.apiQuoteService.postQuoteEvents(10, event)
+     *   .subscribe((response) => console.log(response))
+     * ```
+     */
+    postQuoteEvents(id, body) {
+        return this.http.post(`${this.url}/quotes/${id}/quote-events`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the available quote event types.
+     *
+     * @param params - Optional query parameters such as pagination or filtering.
+     * @returns Observable containing the list of event types.
+     *
+     * @example
+     * ```ts
+     * this.apiQuoteService.getQuoteEventTypes({ page: 1 })
+     *   .subscribe((types) => console.log(types))
+     * ```
+     */
+    getQuoteEventTypes(params) {
+        return this.http.get(`${this.url}/quote-event-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiQuoteService, 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: ApiQuoteService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiQuoteService, 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

@@ -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":"AACA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EAAE,GAAG,EAAc,MAAM,MAAM,CAAA;;;AAatC,MAAM,OAAO,iBAAiB;IAEH;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,aAAa,IAAI,EAAE,CAAA;IAC9C,CAAC;IAED;;;;;OAKG;IACH,qBAAqB,CAAE,MAAmB;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAoC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE;YACxF,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,kBAAkB,CAAE,MAAmB;QACrC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAiC,GAAG,IAAI,CAAC,GAAG,mBAAmB,EAAE,EAAE,MAAM,EAAE,CAAC;aAC7F,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,0BAA0B,CAAE,MAAmB;QAC7C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAmC,GAAG,IAAI,CAAC,GAAG,4BAA4B,EAAE,EAAE,MAAM,EAAE,CAAC;aACxG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAE,MAAmB;QAC5C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAwC,GAAG,IAAI,CAAC,GAAG,2BAA2B,EAAE;YAClG,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAE,aAAqB;QAChC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,aAAa,aAAa,EAAE,EAAE;YAC5D,OAAO,EAAE,UAAU;YACnB,YAAY,EAAE,aAAa;SAC5B,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAE,aAAqB;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA2B,GAAG,IAAI,CAAC,GAAG,eAAe,aAAa,EAAE,CAAC;aACtF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAE,aAAqB;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAiB,GAAG,IAAI,CAAC,GAAG,eAAe,aAAa,EAAE,CAAC;aAC/E,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,qBAAqB,CAAE,MAAmB;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAoC,GAAG,IAAI,CAAC,GAAG,sBAAsB,EAAE;YACzF,MAAM;SACP,CAAC;aACC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAE,MAAmB;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA0B,GAAG,IAAI,CAAC,GAAG,WAAW,EAAE,EAAE,MAAM,EAAE,CAAC;aAC9E,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;wGAtHU,iBAAiB,kBAElB,KAAK;4GAFJ,iBAAiB,cAFhB,MAAM;;4FAEP,iBAAiB;kBAH7B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAGI,MAAM;2BAAC,KAAK","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-quote.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXF1b3RlLmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9leHBlcnRlYW0tbXgvbmd4LXNlcnZpY2VzL3NyYy9saWIvYXBpcy9tb2RlbHMvYXBpLXF1b3RlLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFjdGl2ZUxlc3NTeW1mb255TW9kZWwsIFN5bWZvbnlNb2RlbCB9IGZyb20gJy4vYXBpLm1vZGVscydcblxuZXhwb3J0IGludGVyZmFjZSBRdW90ZUV2ZW50IGV4dGVuZHMgQWN0aXZlTGVzc1N5bWZvbnlNb2RlbCB7XG4gIGRhdGU6IHN0cmluZ1xuICBxdW90ZUV2ZW50VHlwZTogUXVvdGVFdmVudFR5cGVcbiAgY29tbWVudDogc3RyaW5nXG4gIHVzZXJJZDogbnVtYmVyXG4gIHVzZXJVc2VybmFtZTogc3RyaW5nXG4gIHVzZXJOYW1lOiBzdHJpbmdcbn1cblxuZXhwb3J0IGludGVyZmFjZSBRdW90ZUV2ZW50VHlwZSBleHRlbmRzIFN5bWZvbnlNb2RlbCB7XG4gIGNvZGU6IHN0cmluZ1xuICBuYW1lOiBzdHJpbmdcbn1cbiJdfQ==

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXF1b3RlLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXhwZXJ0ZWFtLW14L25neC1zZXJ2aWNlcy9zcmMvbGliL2FwaXMvbW9kZWxzL2FwaS1xdW90ZS50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUXVvdGVFdmVudCwgUXVvdGVFdmVudFR5cGUgfSBmcm9tICcuL2FwaS1xdW90ZS5pbnRlcmZhY2VzJ1xuXG5leHBvcnQgdHlwZSBRdW90ZUV2ZW50c091dCA9IHtcbiAgdG90YWw6IG51bWJlclxuICBxdW90ZUV2ZW50czogUXVvdGVFdmVudFtdXG59XG5cbmV4cG9ydCB0eXBlIFF1b3RlRXZlbnRJbiA9IHtcbiAgZGF0ZTogc3RyaW5nXG4gIHF1b3RlRXZlbnRUeXBlSWQ6IG51bWJlclxuICBjb21tZW50OiBzdHJpbmdcbn1cblxuZXhwb3J0IGludGVyZmFjZSBRdW90ZUV2ZW50T3V0IHtcbiAgcXVvdGVFdmVudDogUXVvdGVFdmVudFxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFF1b3RlRXZlbnRUeXBlc091dCB7XG4gIHRvdGFsOiBudW1iZXJcbiAgcXVvdGVFdmVudFR5cGVzOiBRdW90ZUV2ZW50VHlwZVtdXG59XG4iXX0=

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  amount_details: PromotionCodeDiscountAmountDetail[]\n}\n\nexport interface PromotionCodeDiscountAmountDetail {\n  country_reference_currency_id: number\n  currency_id: number\n  currency_code: string\n  product_subtotal: 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 ProductSubtotal {\n  country_reference_currency_id: number\n  currency_id: number\n  currency_code: string\n  value: 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/lib/ngx-services.models.mjs

@@ -8,4 +8,4 @@ import { InjectionToken } from '@angular/core';
  * `Environment` type that defines the structure of the configuration.
  */
 export const ENVIRONMENT_TOKEN = new InjectionToken('Environments token');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LXNlcnZpY2VzLm1vZGVscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2V4cGVydGVhbS1teC9uZ3gtc2VydmljZXMvc3JjL2xpYi9uZ3gtc2VydmljZXMubW9kZWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUE7QUF1RDlDOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLGNBQWMsQ0FBYyxvQkFBb0IsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG4vKipcbiAqIFJlcHJlc2VudHMgdGhlIGNvbmZpZ3VyYXRpb24gc2V0dGluZ3MgZm9yIHRoZSBhcHBsaWNhdGlvbidzIGVudmlyb25tZW50LlxuICogVGhpcyB0eXBlIGluY2x1ZGVzIHZhcmlvdXMgQVBJIGVuZHBvaW50IFVSTHMsIGF1dGhlbnRpY2F0aW9uIGRldGFpbHMsIGNhY2hpbmcgb3B0aW9ucywgYW5kIG90aGVyIHJlbGV2YW50IHNldHRpbmdzLlxuICpcbiAqIFByb3BlcnRpZXM6XG4gKiAtIGFwaUNvbXBhbmllc1VybDogVGhlIFVSTCBmb3IgdGhlIGNvbXBhbmllcyBBUEkgZW5kcG9pbnQuXG4gKiAtIGFwaUV2ZW50c1VybDogVGhlIFVSTCBmb3IgdGhlIGV2ZW50cyBBUEkgZW5kcG9pbnQuXG4gKiAtIGFwaUludm9pY2VzVXJsOiBUaGUgVVJMIGZvciB0aGUgaW52b2ljZXMgQVBJIGVuZHBvaW50LlxuICogLSBhcGlSZXBvcnRzVXJsOiBUaGUgVVJMIGZvciB0aGUgcmVwb3J0cyBBUEkgZW5kcG9pbnQuXG4gKiAtIGFwaVNlY3VyaXR5VXJsOiBUaGUgVVJMIGZvciB0aGUgc2VjdXJpdHktcmVsYXRlZCBBUEkgZW5kcG9pbnQuXG4gKiAtIGFwaVNoaXBtZW50VXJsOiBUaGUgVVJMIGZvciB0aGUgc2hpcG1lbnQgQVBJIGVuZHBvaW50LlxuICogLSBhdXRoQ29va2llOiBUaGUgbmFtZSBvZiB0aGUgYXV0aGVudGljYXRpb24gY29va2llIHVzZWQgZm9yIHVzZXIgc2Vzc2lvbnMuXG4gKiAtIGNhY2hlVHRsOiBPcHRpb25hbC4gU3BlY2lmaWVzIHRoZSB0aW1lLXRvLWxpdmUgKFRUTCkgZm9yIGNhY2hlZCBpdGVtcy5cbiAqIC0gcHJpbnRVcmw6IE9wdGlvbmFsLiBUaGUgVVJMIHVzZWQgZm9yIGdlbmVyYXRpbmcgb3IgZG93bmxvYWRpbmcgcHJpbnRhYmxlIGRvY3VtZW50cy5cbiAqIC0gc2VjcmV0S2V5OiBBIHNlY3JldCBrZXkgdXNlZCBmb3IgYXV0aGVudGljYXRpb24gb3Igb3RoZXIgc2VjdXJlIG9wZXJhdGlvbnMuXG4gKi9cbmV4cG9ydCB0eXBlIEVudmlyb25tZW50ID0ge1xuICBhcGlCaWxsaW5nRE8/OiBzdHJpbmdcbiAgYXBpQmlsbGluZ0dUPzogc3RyaW5nXG4gIGFwaUJpbGxpbmdNWD86IHN0cmluZ1xuICBhcGlCaWxsaW5nUEE/OiBzdHJpbmdcbiAgYXBpQmlsbGluZ1NWPzogc3RyaW5nXG4gIGFwaUNhc2hPcGVyYXRpb25zVXJsPzogc3RyaW5nXG4gIGFwaUNhdGFsb2dzVXJsPzogc3RyaW5nXG4gIGFwaUNvbXBhbmllc1VybD86IHN0cmluZ1xuICBhcGlDb21wb3NpdGlvblVybD86IHN0cmluZ1xuICBhcGlDdXN0b21zVXJsPzogc3RyaW5nXG4gIGFwaURpc2NvdW50c1VybD86IHN0cmluZ1xuICBhcGlFdmVudHNVcmw/OiBzdHJpbmdcbiAgYXBpRVRvb2xzQXV0b0JpbGxpbmc/OiBzdHJpbmdcbiAgYXBpRXh0ZXJuYWxPcGVyYXRpb25zS2V5Pzogc3RyaW5nXG4gIGFwaUV4dGVybmFsT3BlcmF0aW9uc1VybD86IHN0cmluZ1xuICBhcGlJbnZlbnRvcmllc1VybD86IHN0cmluZ1xuICBhcGlJbnZvaWNlc1VybD86IHN0cmluZ1xuICBhcGlOb3RpZmljYXRpb25zVXJsPzogc3RyaW5nXG4gIGFwaU9wZW5JdGVtc1VybD86IHN0cmluZ1xuICBhcGlSZXBvcnRzVXJsPzogc3RyaW5nXG4gIGFwaVNlY3VyaXR5VXJsPzogc3RyaW5nXG4gIGFwaVNlcnZpY2VzVXJsPzogc3RyaW5nXG4gIGFwaVNoaXBtZW50VXJsPzogc3RyaW5nXG4gIGFwaVN1cHBsaWVzVXJsPzogc3RyaW5nXG4gIGF1dGhDb29raWU6IHN0cmluZ1xuICBjYWNoZVR0bD86IG51bWJlclxuICBwcmludFVybD86IHN0cmluZ1xuICBzZWNyZXRLZXk6IHN0cmluZ1xuICBzb2NrZXRzPzoge1xuICAgIGFwcF9rZXk6IHN0cmluZ1xuICAgIGRlYnVnPzogYm9vbGVhblxuICAgIHBvcnQ6IG51bWJlclxuICAgIHVybDogc3RyaW5nXG4gIH1cbn1cblxuLyoqXG4gKiBJbmplY3Rpb24gdG9rZW4gdXNlZCB0byBpbmplY3QgZW52aXJvbm1lbnQgY29uZmlndXJhdGlvbnMuXG4gKlxuICogYEVOVklST05NRU5UX1RPS0VOYCBpcyBhIGRlcGVuZGVuY3kgaW5qZWN0aW9uIHRva2VuIHRoYXQgYWxsb3dzXG4gKiBmb3IgdGhlIHByb3Zpc2lvbiBhbmQgcmV0cmlldmFsIG9mIGVudmlyb25tZW50LXNwZWNpZmljIGNvbmZpZ3VyYXRpb25zXG4gKiB3aXRoaW4gdGhlIGFwcGxpY2F0aW9uLiBUaGlzIHRva2VuIGlzIHR5cGljYWxseSBhc3NvY2lhdGVkIHdpdGggYW5cbiAqIGBFbnZpcm9ubWVudGAgdHlwZSB0aGF0IGRlZmluZXMgdGhlIHN0cnVjdHVyZSBvZiB0aGUgY29uZmlndXJhdGlvbi5cbiAqL1xuZXhwb3J0IGNvbnN0IEVOVklST05NRU5UX1RPS0VOID0gbmV3IEluamVjdGlvblRva2VuPEVudmlyb25tZW50PignRW52aXJvbm1lbnRzIHRva2VuJylcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -22,6 +22,7 @@ export * from './lib/apis/api-inventories.service';
 export * from './lib/apis/api-invoices.service';
 export * from './lib/apis/api-notifications.service';
 export * from './lib/apis/api-open-items.service';
+export * from './lib/apis/api-quote.service';
 export * from './lib/apis/api-reports.service';
 export * from './lib/apis/api-security.service';
 export * from './lib/apis/api-services.service';
@@ -65,7 +66,10 @@ export * from './lib/apis/models/api-notifications.interfaces';
 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-quote.interfaces';
+export * from './lib/apis/models/api-quote.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';
@@ -87,4 +91,4 @@ export * from './lib/interceptors/http-caching.interceptor';
 // helpers
 export * from './lib/helpers/files';
 export * from './lib/helpers/http';
-//# 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,6CAA6C,CAAA;AAC3D,cAAc,+BAA+B,CAAA;AAC7C,cAAc,qCAAqC,CAAA;AACnD,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,0CAA0C,CAAA;AACxD,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,wCAAwC,CAAA;AACtD,cAAc,0CAA0C,CAAA;AACxD,cAAc,6CAA6C,CAAA;AAE3D,UAAU;AACV,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,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-e-tools-auto-billing.service'\nexport * from './lib/apis/api-events.service'\nexport * from './lib/apis/api-external-ops.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-ops.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-key.interceptor'\nexport * from './lib/interceptors/api-token.interceptor'\nexport * from './lib/interceptors/http-caching.interceptor'\n\n// helpers\nexport * from './lib/helpers/files'\nexport * from './lib/helpers/http'\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,6CAA6C,CAAA;AAC3D,cAAc,+BAA+B,CAAA;AAC7C,cAAc,qCAAqC,CAAA;AACnD,cAAc,oCAAoC,CAAA;AAClD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,mCAAmC,CAAA;AACjD,cAAc,8BAA8B,CAAA;AAC5C,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,0CAA0C,CAAA;AACxD,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,wCAAwC,CAAA;AACtD,cAAc,mCAAmC,CAAA;AACjD,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,wCAAwC,CAAA;AACtD,cAAc,0CAA0C,CAAA;AACxD,cAAc,6CAA6C,CAAA;AAE3D,UAAU;AACV,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,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-e-tools-auto-billing.service'\nexport * from './lib/apis/api-events.service'\nexport * from './lib/apis/api-external-ops.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-quote.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-ops.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-quote.interfaces'\nexport * from './lib/apis/models/api-quote.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-key.interceptor'\nexport * from './lib/interceptors/api-token.interceptor'\nexport * from './lib/interceptors/http-caching.interceptor'\n\n// helpers\nexport * from './lib/helpers/files'\nexport * from './lib/helpers/http'\n"]}