@experteam-mx/ngx-services 18.7.29 → 18.7.31

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

@@ -379,6 +379,80 @@ export class ApiCatalogsService {
         return this.http.get(`${this.url}/shipment-statuses`, { params })
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Fetches questions from the catalogs API.
+     *
+     * Sends an HTTP GET request to `${this.url}/questions` using the supplied query parameters
+     * and returns the unwrapped payload (`data`) from the API response.
+     *
+     * @param params - Query parameters to include in the request (e.g. paging, filters, sorting).
+     * @returns An Observable that emits the QuestionsOut payload (the `data` field from ApiSuccess<QuestionsOut>).
+     */
+    getQuestions(params) {
+        return this.http.get(`${this.url}/questions`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieve a single question by its id.
+     *
+     * Sends an HTTP GET request to the questions endpoint and returns an Observable that emits
+     * the QuestionOut payload extracted from the API success envelope.
+     *
+     * @param id - The numeric identifier of the question to fetch.
+     * @returns An Observable that emits the requested QuestionOut. The Observable will error
+     *          if the HTTP request fails (for example network issues or non-2xx responses).
+     */
+    getQuestion(id) {
+        return this.http.get(`${this.url}/questions/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create a new question and returns the created resource.
+     *
+     * The request payload is sent as an object with a `body` property containing the provided
+     * QuestionIn value (i.e. { body: QuestionIn }). On success the HTTP response is expected
+     * to follow the ApiSuccess<T> shape; the operator maps that response to the inner `data`
+     * object and emits it as a QuestionOut.
+     *
+     * @param body - The question payload to create (QuestionIn).
+     * @returns Observable<QuestionOut> that emits the created question on success.
+     */
+    postQuestion(body) {
+        return this.http.post(`${this.url}/questions`, { body })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Update a question by its ID.
+     *
+     * Sends an HTTP PUT to `${this.url}/questions/${id}` with the provided payload.
+     * The request body is sent as an object with a `body` property containing the
+     * `QuestionIn` data. The server response is expected to be an `ApiSuccess<QuestionOut>`
+     * and this method returns an Observable that emits the unwrapped `QuestionOut`.
+     *
+     * @param id - The identifier of the question to update.
+     * @param body - The update payload for the question.
+     * @returns An Observable that emits the updated `QuestionOut` on success.
+     */
+    putQuestion(id, body) {
+        return this.http.put(`${this.url}/questions/${id}`, { body })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes a question by its ID.
+     *
+     * Sends an HTTP DELETE request to the backend endpoint `/questions/{id}` and
+     * returns an Observable that emits the API response's `data` payload (typically an empty object).
+     *
+     * The implementation maps an ApiSuccess wrapper to its `data` property before emitting.
+     *
+     * @param id - The numeric identifier of the question to delete.
+     * @returns An Observable that emits the deleted resource payload ({} expected) on success.
+     *          The Observable will emit an error if the HTTP request fails.
+     */
+    deleteQuestion(id) {
+        return this.http.delete(`${this.url}/questions/${id}`)
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCatalogsService, 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: ApiCatalogsService, providedIn: 'root' });
 }
@@ -391,4 +465,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-catalogs.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-catalogs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport { map, Observable } from 'rxjs'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport {\r\n  CancellationReasonIn,\r\n  CancellationReasonOut,\r\n  CancellationReasonsOut,\r\n  CountriesOut,\r\n  CountryIn,\r\n  CountryOut,\r\n  CurrenciesOut,\r\n  ExtraChargeIn,\r\n  ExtraChargeOut,\r\n  ExtraChargesOut,\r\n  GenericFolioIn,\r\n  GenericFolioOut,\r\n  GenericFoliosOut,\r\n  IdentificationTypesOut,\r\n  LanguagesOut,\r\n  ManagementAreasOut,\r\n  OperationTypesOut,\r\n  PostalLocationsOut,\r\n  ProductIn,\r\n  ProductOut,\r\n  RegionsOut,\r\n  ShipmentContentTypesOut,\r\n  ShipmentGroupsOut,\r\n  ShipmentIncomeTypeIn,\r\n  ShipmentIncomeTypeOut,\r\n  ShipmentIncomeTypesOut,\r\n  ShipmentScopesOut,\r\n  ShipmentStatusesOut,\r\n  UniqueFolioIn,\r\n  UniqueFolioOut,\r\n  UniqueFoliosOut,\r\n  UnitsOut,\r\n  ZonesOut\r\n} from './models/api-catalog.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCatalogsService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the URL for the reports API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the reports API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCatalogsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of collection payments\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the operation types.\r\n   * @return {Observable<OperationTypesOut[]>} An observable that emits an array of operation type.\r\n   */\r\n  getOperationTypes (params: QueryParams): Observable<OperationTypesOut> {\r\n    return this.http.get<ApiSuccess<OperationTypesOut>>(`${this.url}/operation-types`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of identificatios types\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the identification types.\r\n   * @return {Observable<IdentificationTypesOut[]>} An observable that emits an array of identification type.\r\n   */\r\n  getIdentificationTypes (params: QueryParams): Observable<IdentificationTypesOut> {\r\n    return this.http.get<ApiSuccess<IdentificationTypesOut>>(`${this.url}/identification-types`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the extra charges based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the results.\r\n   * @return {Observable<ExtraChargesOut>} An observable emitting the extra charges data.\r\n   */\r\n  getExtraCharges (params: QueryParams): Observable<ExtraChargesOut> {\r\n    return this.http.get<ApiSuccess<ExtraChargesOut>>(`${this.url}/extracharges`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Submits an extra charge request to the server and returns the created extra charge details.\r\n   *\r\n   * @param {ExtraChargeIn} body - The data for the extra charge to be created.\r\n   * @return {Observable<ExtraChargeOut>} An observable that emits the details of the created extra charge.\r\n   */\r\n  postExtraCharge (body: ExtraChargeIn): Observable<ExtraChargeOut> {\r\n    return this.http.post<ApiSuccess<ExtraChargeOut>>(`${this.url}/extracharges`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an extra charge entity with new data and returns the updated entity.\r\n   *\r\n   * @param {number} id - The unique identifier of the extra charge to update.\r\n   * @param {ExtraChargeIn} body - The new data for the extra charge.\r\n   * @return {Observable<ExtraChargeOut>} An observable emitting the updated extra charge entity.\r\n   */\r\n  putExtraCharge (id: number, body: ExtraChargeIn): Observable<ExtraChargeOut> {\r\n    return this.http.put<ApiSuccess<ExtraChargeOut>>(`${this.url}/extracharges/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of countries from the API.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to be passed to the API request.\r\n   * @return {Observable<CountriesOut>} An observable containing the list of countries.\r\n   */\r\n  getCountries (params: QueryParams): Observable<CountriesOut> {\r\n    return this.http.get<ApiSuccess<CountriesOut>>(`${this.url}/countries`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the details of a country based on its ID.\r\n   *\r\n   * @param {number} id - The identifier of the country to fetch.\r\n   * @return {Observable<CountryOut>} An observable that emits the country data.\r\n   */\r\n  getCountry (id: number): Observable<CountryOut> {\r\n    return this.http.get<ApiSuccess<CountryOut>>(`${this.url}/countries/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the details of a specific country by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country to be updated.\r\n   * @param {CountryIn} body - The data to update the country with.\r\n   * @return {Observable<CountryOut>} An observable that emits the updated country data.\r\n   */\r\n  putCountry (id: number, body: CountryIn): Observable<CountryOut> {\r\n    return this.http.put<ApiSuccess<CountryOut>>(`${this.url}/countries/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches postal location details based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter and fetch postal location data.\r\n   * @return {Observable<PostalLocationsOut>} An observable that emits the postal location details.\r\n   */\r\n  getPostalLocations (params: QueryParams): Observable<PostalLocationsOut> {\r\n    return this.http.get<ApiSuccess<PostalLocationsOut>>(`${this.url}/postal-locations`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of regions based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter the regions.\r\n   * @return {Observable<RegionsOut>} An observable that emits the list of regions.\r\n   */\r\n  getRegions (params: QueryParams): Observable<RegionsOut> {\r\n    return this.http.get<ApiSuccess<RegionsOut>>(`${this.url}/regions`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the zones data based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter the zones data.\r\n   * @return {Observable<ZonesOut>} An observable that emits the fetched zones data.\r\n   */\r\n  getZones (params: QueryParams): Observable<ZonesOut> {\r\n    return this.http.get<ApiSuccess<ZonesOut>>(`${this.url}/zones`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the management areas based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the management areas.\r\n   * @return {Observable<ManagementAreasOut>} An observable that emits the management areas data.\r\n   */\r\n  getManagementAreas (params: QueryParams): Observable<ManagementAreasOut> {\r\n    return this.http.get<ApiSuccess<ManagementAreasOut>>(`${this.url}/management-areas`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves cancellation reasons from the server based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the cancellation reasons.\r\n   * @return {Observable<CancellationReasonsOut>} An observable containing the retrieved cancellation reasons.\r\n   */\r\n  getCancellationReasons (params: QueryParams): Observable<CancellationReasonsOut> {\r\n    return this.http.get<ApiSuccess<CancellationReasonsOut>>(`${this.url}/cancellation-reasons`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a cancellation reason to the server.\r\n   *\r\n   * @param {CancellationReasonIn} body - The cancellation reason object to be sent.\r\n   * @return {Observable<CancellationReasonOut>} An observable containing the server's response with the processed cancellation reason.\r\n   */\r\n  postCancellationReason (body: CancellationReasonIn): Observable<CancellationReasonOut> {\r\n    return this.http.post<ApiSuccess<CancellationReasonOut>>(`${this.url}/cancellation-reasons`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the cancellation reason for the specified ID with the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the cancellation reason to update.\r\n   * @param {CancellationReasonIn} body - The details of the cancellation reason to be updated.\r\n   * @return {Observable<CancellationReasonOut>} An observable containing the updated cancellation reason.\r\n   */\r\n  putCancellationReason (id: number, body: CancellationReasonIn): Observable<CancellationReasonOut> {\r\n    return this.http.put<ApiSuccess<CancellationReasonOut>>(`${this.url}/cancellation-reasons/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of currencies based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to customize the currency retrieval request.\r\n   * @return {Observable<CurrenciesOut>} An observable that emits the retrieved currencies data.\r\n   */\r\n  getCurrencies (params: QueryParams): Observable<CurrenciesOut> {\r\n    return this.http.get<ApiSuccess<CurrenciesOut>>(`${this.url}/currencies`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of available languages based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to pass with the HTTP request.\r\n   * @return {Observable<LanguagesOut>} An observable that emits the available languages.\r\n   */\r\n  getLanguages (params: QueryParams): Observable<LanguagesOut> {\r\n    return this.http.get<ApiSuccess<LanguagesOut>>(`${this.url}/languages`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the available units from the API based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the units being fetched.\r\n   * @return {Observable<UnitsOut>} An observable that emits the retrieved units data.\r\n   */\r\n  getUnits (params: QueryParams): Observable<UnitsOut> {\r\n    return this.http.get<ApiSuccess<UnitsOut>>(`${this.url}/units`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the shipment scopes based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params The query parameters to filter or modify the request for shipment scopes.\r\n   * @return {Observable<ShipmentScopesOut>} An observable that emits the shipment scopes data.\r\n   */\r\n  getShipmentScopes (params: QueryParams): Observable<ShipmentScopesOut> {\r\n    return this.http.get<ApiSuccess<ShipmentScopesOut>>(`${this.url}/shipment-scopes`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the available shipment content types based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the shipment content types.\r\n   * @return {Observable<ShipmentContentTypesOut>} An observable that emits the shipment content types data.\r\n   */\r\n  getShipmentContentTypes (params: QueryParams): Observable<ShipmentContentTypesOut> {\r\n    return this.http.get<ApiSuccess<ShipmentContentTypesOut>>(`${this.url}/shipment-content-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of generic folios based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter the generic folios.\r\n   * @return {Observable<GenericFoliosOut>} An observable containing the fetched generic folios.\r\n   */\r\n  getGenericFolios (params: QueryParams): Observable<GenericFoliosOut> {\r\n    return this.http.get<ApiSuccess<GenericFoliosOut>>(`${this.url}/generic-folios`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update a generic folio.\r\n   *\r\n   * @param {GenericFolioIn} body - The payload containing the details of the generic folio to be created or updated.\r\n   * @return {Observable<GenericFolioOut>} An observable containing the response data of the created or updated generic folio.\r\n   */\r\n  postGenericFolio (body: GenericFolioIn): Observable<GenericFolioOut> {\r\n    return this.http.post<ApiSuccess<GenericFolioOut>>(`${this.url}/generic-folios`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates a generic folio with the specified ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the generic folio to update.\r\n   * @param {GenericFolioIn} body - The data to update the generic folio with.\r\n   * @return {Observable<GenericFolioOut>} An observable containing the updated generic folio.\r\n   */\r\n  putGenericFolio (id: number, body: GenericFolioIn): Observable<GenericFolioOut> {\r\n    return this.http.put<ApiSuccess<GenericFolioOut>>(`${this.url}/generic-folios/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a PUT request to update a Generic Folio resource with the specified ID and body data, and returns the updated resource.\r\n   *\r\n   * @param {number} id - The unique identifier of the Generic Folio to be updated.\r\n   * @param {Partial<GenericFolioIn>} body - The partial data representing the changes to be applied to the Generic Folio.\r\n   * @return {Observable<GenericFolioOut>} An observable containing the updated Generic Folio resource.\r\n   */\r\n  pathGenericFolio (id: number, body: Partial<GenericFolioIn>): Observable<GenericFolioOut> {\r\n    return this.http.put<ApiSuccess<GenericFolioOut>>(`${this.url}/generic-folios/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a new product.\r\n   *\r\n   * @param {ProductIn} body - The product data to be sent in the request body.\r\n   * @return {Observable<ProductOut>} An observable emitting the created product data.\r\n   */\r\n  postProduct (body: ProductIn): Observable<ProductOut> {\r\n    return this.http.post<ApiSuccess<ProductOut>>(`${this.url}/products`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing product with the given ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the product to update.\r\n   * @param {ProductIn} body - The product data to update.\r\n   * @return {Observable<ProductOut>} An observable containing the updated product data.\r\n   */\r\n  putProduct (id: number, body: ProductIn): Observable<ProductOut> {\r\n    return this.http.put<ApiSuccess<ProductOut>>(`${this.url}/products/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of shipment income types based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the shipment income types.\r\n   * @return {Observable<ShipmentIncomeTypesOut>} An observable containing the shipment income types data.\r\n   */\r\n  getShipmentIncomeTypes (params: QueryParams): Observable<ShipmentIncomeTypesOut> {\r\n    return this.http.get<ApiSuccess<ShipmentIncomeTypesOut>>(`${this.url}/shipment-income-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a new shipment income type.\r\n   *\r\n   * @param {ShipmentIncomeTypeIn} body The payload containing the details of the shipment income type to be created.\r\n   * @return {Observable<ShipmentIncomeTypeOut>} An observable that emits the created shipment income type data.\r\n   */\r\n  postShipmentIncomeType (body: ShipmentIncomeTypeIn): Observable<ShipmentIncomeTypeOut> {\r\n    return this.http.post<ApiSuccess<ShipmentIncomeTypeOut>>(`${this.url}/shipment-income-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the shipment income type with the specified ID.\r\n   *\r\n   * @param {number} id - The identifier of the shipment income type to update.\r\n   * @param {ShipmentIncomeTypeIn} body - The data to update the shipment income type with.\r\n   * @return {Observable<ShipmentIncomeTypeOut>} An observable emitting the updated shipment income type.\r\n   */\r\n  putShipmentIncomeType (id: number, body: ShipmentIncomeTypeIn): Observable<ShipmentIncomeTypeOut> {\r\n    return this.http.put<ApiSuccess<ShipmentIncomeTypeOut>>(`${this.url}/shipment-income-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of unique folios based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and fetch unique folios.\r\n   * @return {Observable<UniqueFoliosOut>} An observable that emits the unique folios data.\r\n   */\r\n  getUniqueFolios (params: QueryParams): Observable<UniqueFoliosOut> {\r\n    return this.http.get<ApiSuccess<UniqueFoliosOut>>(`${this.url}/unique-folios`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a unique folio.\r\n   *\r\n   * @param {UniqueFolioIn} body - The data object containing details for the unique folio to be created.\r\n   * @return {Observable<UniqueFolioOut>} An observable that emits the created unique folio details.\r\n   */\r\n  postUniqueFolio (body: UniqueFolioIn): Observable<UniqueFolioOut> {\r\n    return this.http.post<ApiSuccess<UniqueFolioOut>>(`${this.url}/unique-folios`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates a unique folio with the given data using the provided ID.\r\n   *\r\n   * @param {number} id - The ID of the unique folio to be updated.\r\n   * @param {UniqueFolioIn} body - The payload containing the details of the unique folio to update.\r\n   * @return {Observable<UniqueFolioOut>} An observable that emits the updated unique folio.\r\n   */\r\n  putUniqueFolio (id: number, body: UniqueFolioIn): Observable<UniqueFolioOut> {\r\n    return this.http.put<ApiSuccess<UniqueFolioOut>>(`${this.url}/unique-folios/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates a unique folio by its identifier with the provided data.\r\n   *\r\n   * @param {number} id - The identifier of the unique folio to update.\r\n   * @param {Partial<UniqueFolioIn>} body - The partial data of the unique folio to update.\r\n   * @return {Observable<UniqueFolioOut>} An observable emitting the updated unique folio data.\r\n   */\r\n  pathUniqueFolio (id: number, body: Partial<UniqueFolioIn>): Observable<UniqueFolioOut> {\r\n    return this.http.put<ApiSuccess<UniqueFolioOut>>(`${this.url}/unique-folios/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves shipment groups based on the provided query parameters.\r\n   *\r\n   * @param params - The query parameters to filter the shipment groups.\r\n   * @returns An Observable that emits the shipment groups data.\r\n   */\r\n  getShipmentGroups (params: QueryParams): Observable<ShipmentGroupsOut> {\r\n    return this.http.get<ApiSuccess<ShipmentGroupsOut>>(`${this.url}/shipment-groups`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the shipment statuses from the API.\r\n   *\r\n   * @param params - The query parameters to filter or modify the request.\r\n   * @returns An Observable that emits the shipment statuses output.\r\n   */\r\n  getShipmentStatuses (params: QueryParams): Observable<ShipmentStatusesOut> {\r\n    return this.http.get<ApiSuccess<ShipmentStatusesOut>>(`${this.url}/shipment-statuses`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-catalogs.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-catalogs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport { map, Observable } from 'rxjs'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport {\r\n  CancellationReasonIn,\r\n  CancellationReasonOut,\r\n  CancellationReasonsOut,\r\n  CountriesOut,\r\n  CountryIn,\r\n  CountryOut,\r\n  CurrenciesOut,\r\n  ExtraChargeIn,\r\n  ExtraChargeOut,\r\n  ExtraChargesOut,\r\n  GenericFolioIn,\r\n  GenericFolioOut,\r\n  GenericFoliosOut,\r\n  IdentificationTypesOut,\r\n  LanguagesOut,\r\n  ManagementAreasOut,\r\n  OperationTypesOut,\r\n  PostalLocationsOut,\r\n  ProductIn,\r\n  ProductOut,\r\n  QuestionIn,\r\n  QuestionOut,\r\n  QuestionsOut,\r\n  RegionsOut,\r\n  ShipmentContentTypesOut,\r\n  ShipmentGroupsOut,\r\n  ShipmentIncomeTypeIn,\r\n  ShipmentIncomeTypeOut,\r\n  ShipmentIncomeTypesOut,\r\n  ShipmentScopesOut,\r\n  ShipmentStatusesOut,\r\n  UniqueFolioIn,\r\n  UniqueFolioOut,\r\n  UniqueFoliosOut,\r\n  UnitsOut,\r\n  ZonesOut\r\n} from './models/api-catalog.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCatalogsService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the URL for the reports API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the reports API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCatalogsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of collection payments\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the operation types.\r\n   * @return {Observable<OperationTypesOut[]>} An observable that emits an array of operation type.\r\n   */\r\n  getOperationTypes (params: QueryParams): Observable<OperationTypesOut> {\r\n    return this.http.get<ApiSuccess<OperationTypesOut>>(`${this.url}/operation-types`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of identificatios types\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the identification types.\r\n   * @return {Observable<IdentificationTypesOut[]>} An observable that emits an array of identification type.\r\n   */\r\n  getIdentificationTypes (params: QueryParams): Observable<IdentificationTypesOut> {\r\n    return this.http.get<ApiSuccess<IdentificationTypesOut>>(`${this.url}/identification-types`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the extra charges based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the results.\r\n   * @return {Observable<ExtraChargesOut>} An observable emitting the extra charges data.\r\n   */\r\n  getExtraCharges (params: QueryParams): Observable<ExtraChargesOut> {\r\n    return this.http.get<ApiSuccess<ExtraChargesOut>>(`${this.url}/extracharges`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Submits an extra charge request to the server and returns the created extra charge details.\r\n   *\r\n   * @param {ExtraChargeIn} body - The data for the extra charge to be created.\r\n   * @return {Observable<ExtraChargeOut>} An observable that emits the details of the created extra charge.\r\n   */\r\n  postExtraCharge (body: ExtraChargeIn): Observable<ExtraChargeOut> {\r\n    return this.http.post<ApiSuccess<ExtraChargeOut>>(`${this.url}/extracharges`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an extra charge entity with new data and returns the updated entity.\r\n   *\r\n   * @param {number} id - The unique identifier of the extra charge to update.\r\n   * @param {ExtraChargeIn} body - The new data for the extra charge.\r\n   * @return {Observable<ExtraChargeOut>} An observable emitting the updated extra charge entity.\r\n   */\r\n  putExtraCharge (id: number, body: ExtraChargeIn): Observable<ExtraChargeOut> {\r\n    return this.http.put<ApiSuccess<ExtraChargeOut>>(`${this.url}/extracharges/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of countries from the API.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to be passed to the API request.\r\n   * @return {Observable<CountriesOut>} An observable containing the list of countries.\r\n   */\r\n  getCountries (params: QueryParams): Observable<CountriesOut> {\r\n    return this.http.get<ApiSuccess<CountriesOut>>(`${this.url}/countries`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the details of a country based on its ID.\r\n   *\r\n   * @param {number} id - The identifier of the country to fetch.\r\n   * @return {Observable<CountryOut>} An observable that emits the country data.\r\n   */\r\n  getCountry (id: number): Observable<CountryOut> {\r\n    return this.http.get<ApiSuccess<CountryOut>>(`${this.url}/countries/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the details of a specific country by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country to be updated.\r\n   * @param {CountryIn} body - The data to update the country with.\r\n   * @return {Observable<CountryOut>} An observable that emits the updated country data.\r\n   */\r\n  putCountry (id: number, body: CountryIn): Observable<CountryOut> {\r\n    return this.http.put<ApiSuccess<CountryOut>>(`${this.url}/countries/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches postal location details based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter and fetch postal location data.\r\n   * @return {Observable<PostalLocationsOut>} An observable that emits the postal location details.\r\n   */\r\n  getPostalLocations (params: QueryParams): Observable<PostalLocationsOut> {\r\n    return this.http.get<ApiSuccess<PostalLocationsOut>>(`${this.url}/postal-locations`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of regions based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter the regions.\r\n   * @return {Observable<RegionsOut>} An observable that emits the list of regions.\r\n   */\r\n  getRegions (params: QueryParams): Observable<RegionsOut> {\r\n    return this.http.get<ApiSuccess<RegionsOut>>(`${this.url}/regions`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the zones data based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter the zones data.\r\n   * @return {Observable<ZonesOut>} An observable that emits the fetched zones data.\r\n   */\r\n  getZones (params: QueryParams): Observable<ZonesOut> {\r\n    return this.http.get<ApiSuccess<ZonesOut>>(`${this.url}/zones`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the management areas based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the management areas.\r\n   * @return {Observable<ManagementAreasOut>} An observable that emits the management areas data.\r\n   */\r\n  getManagementAreas (params: QueryParams): Observable<ManagementAreasOut> {\r\n    return this.http.get<ApiSuccess<ManagementAreasOut>>(`${this.url}/management-areas`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves cancellation reasons from the server based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the cancellation reasons.\r\n   * @return {Observable<CancellationReasonsOut>} An observable containing the retrieved cancellation reasons.\r\n   */\r\n  getCancellationReasons (params: QueryParams): Observable<CancellationReasonsOut> {\r\n    return this.http.get<ApiSuccess<CancellationReasonsOut>>(`${this.url}/cancellation-reasons`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a cancellation reason to the server.\r\n   *\r\n   * @param {CancellationReasonIn} body - The cancellation reason object to be sent.\r\n   * @return {Observable<CancellationReasonOut>} An observable containing the server's response with the processed cancellation reason.\r\n   */\r\n  postCancellationReason (body: CancellationReasonIn): Observable<CancellationReasonOut> {\r\n    return this.http.post<ApiSuccess<CancellationReasonOut>>(`${this.url}/cancellation-reasons`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the cancellation reason for the specified ID with the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the cancellation reason to update.\r\n   * @param {CancellationReasonIn} body - The details of the cancellation reason to be updated.\r\n   * @return {Observable<CancellationReasonOut>} An observable containing the updated cancellation reason.\r\n   */\r\n  putCancellationReason (id: number, body: CancellationReasonIn): Observable<CancellationReasonOut> {\r\n    return this.http.put<ApiSuccess<CancellationReasonOut>>(`${this.url}/cancellation-reasons/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of currencies based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to customize the currency retrieval request.\r\n   * @return {Observable<CurrenciesOut>} An observable that emits the retrieved currencies data.\r\n   */\r\n  getCurrencies (params: QueryParams): Observable<CurrenciesOut> {\r\n    return this.http.get<ApiSuccess<CurrenciesOut>>(`${this.url}/currencies`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of available languages based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to pass with the HTTP request.\r\n   * @return {Observable<LanguagesOut>} An observable that emits the available languages.\r\n   */\r\n  getLanguages (params: QueryParams): Observable<LanguagesOut> {\r\n    return this.http.get<ApiSuccess<LanguagesOut>>(`${this.url}/languages`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the available units from the API based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the units being fetched.\r\n   * @return {Observable<UnitsOut>} An observable that emits the retrieved units data.\r\n   */\r\n  getUnits (params: QueryParams): Observable<UnitsOut> {\r\n    return this.http.get<ApiSuccess<UnitsOut>>(`${this.url}/units`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the shipment scopes based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params The query parameters to filter or modify the request for shipment scopes.\r\n   * @return {Observable<ShipmentScopesOut>} An observable that emits the shipment scopes data.\r\n   */\r\n  getShipmentScopes (params: QueryParams): Observable<ShipmentScopesOut> {\r\n    return this.http.get<ApiSuccess<ShipmentScopesOut>>(`${this.url}/shipment-scopes`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the available shipment content types based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the shipment content types.\r\n   * @return {Observable<ShipmentContentTypesOut>} An observable that emits the shipment content types data.\r\n   */\r\n  getShipmentContentTypes (params: QueryParams): Observable<ShipmentContentTypesOut> {\r\n    return this.http.get<ApiSuccess<ShipmentContentTypesOut>>(`${this.url}/shipment-content-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of generic folios based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter the generic folios.\r\n   * @return {Observable<GenericFoliosOut>} An observable containing the fetched generic folios.\r\n   */\r\n  getGenericFolios (params: QueryParams): Observable<GenericFoliosOut> {\r\n    return this.http.get<ApiSuccess<GenericFoliosOut>>(`${this.url}/generic-folios`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update a generic folio.\r\n   *\r\n   * @param {GenericFolioIn} body - The payload containing the details of the generic folio to be created or updated.\r\n   * @return {Observable<GenericFolioOut>} An observable containing the response data of the created or updated generic folio.\r\n   */\r\n  postGenericFolio (body: GenericFolioIn): Observable<GenericFolioOut> {\r\n    return this.http.post<ApiSuccess<GenericFolioOut>>(`${this.url}/generic-folios`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates a generic folio with the specified ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the generic folio to update.\r\n   * @param {GenericFolioIn} body - The data to update the generic folio with.\r\n   * @return {Observable<GenericFolioOut>} An observable containing the updated generic folio.\r\n   */\r\n  putGenericFolio (id: number, body: GenericFolioIn): Observable<GenericFolioOut> {\r\n    return this.http.put<ApiSuccess<GenericFolioOut>>(`${this.url}/generic-folios/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a PUT request to update a Generic Folio resource with the specified ID and body data, and returns the updated resource.\r\n   *\r\n   * @param {number} id - The unique identifier of the Generic Folio to be updated.\r\n   * @param {Partial<GenericFolioIn>} body - The partial data representing the changes to be applied to the Generic Folio.\r\n   * @return {Observable<GenericFolioOut>} An observable containing the updated Generic Folio resource.\r\n   */\r\n  pathGenericFolio (id: number, body: Partial<GenericFolioIn>): Observable<GenericFolioOut> {\r\n    return this.http.put<ApiSuccess<GenericFolioOut>>(`${this.url}/generic-folios/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a new product.\r\n   *\r\n   * @param {ProductIn} body - The product data to be sent in the request body.\r\n   * @return {Observable<ProductOut>} An observable emitting the created product data.\r\n   */\r\n  postProduct (body: ProductIn): Observable<ProductOut> {\r\n    return this.http.post<ApiSuccess<ProductOut>>(`${this.url}/products`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing product with the given ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the product to update.\r\n   * @param {ProductIn} body - The product data to update.\r\n   * @return {Observable<ProductOut>} An observable containing the updated product data.\r\n   */\r\n  putProduct (id: number, body: ProductIn): Observable<ProductOut> {\r\n    return this.http.put<ApiSuccess<ProductOut>>(`${this.url}/products/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of shipment income types based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the shipment income types.\r\n   * @return {Observable<ShipmentIncomeTypesOut>} An observable containing the shipment income types data.\r\n   */\r\n  getShipmentIncomeTypes (params: QueryParams): Observable<ShipmentIncomeTypesOut> {\r\n    return this.http.get<ApiSuccess<ShipmentIncomeTypesOut>>(`${this.url}/shipment-income-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a new shipment income type.\r\n   *\r\n   * @param {ShipmentIncomeTypeIn} body The payload containing the details of the shipment income type to be created.\r\n   * @return {Observable<ShipmentIncomeTypeOut>} An observable that emits the created shipment income type data.\r\n   */\r\n  postShipmentIncomeType (body: ShipmentIncomeTypeIn): Observable<ShipmentIncomeTypeOut> {\r\n    return this.http.post<ApiSuccess<ShipmentIncomeTypeOut>>(`${this.url}/shipment-income-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the shipment income type with the specified ID.\r\n   *\r\n   * @param {number} id - The identifier of the shipment income type to update.\r\n   * @param {ShipmentIncomeTypeIn} body - The data to update the shipment income type with.\r\n   * @return {Observable<ShipmentIncomeTypeOut>} An observable emitting the updated shipment income type.\r\n   */\r\n  putShipmentIncomeType (id: number, body: ShipmentIncomeTypeIn): Observable<ShipmentIncomeTypeOut> {\r\n    return this.http.put<ApiSuccess<ShipmentIncomeTypeOut>>(`${this.url}/shipment-income-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of unique folios based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and fetch unique folios.\r\n   * @return {Observable<UniqueFoliosOut>} An observable that emits the unique folios data.\r\n   */\r\n  getUniqueFolios (params: QueryParams): Observable<UniqueFoliosOut> {\r\n    return this.http.get<ApiSuccess<UniqueFoliosOut>>(`${this.url}/unique-folios`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a unique folio.\r\n   *\r\n   * @param {UniqueFolioIn} body - The data object containing details for the unique folio to be created.\r\n   * @return {Observable<UniqueFolioOut>} An observable that emits the created unique folio details.\r\n   */\r\n  postUniqueFolio (body: UniqueFolioIn): Observable<UniqueFolioOut> {\r\n    return this.http.post<ApiSuccess<UniqueFolioOut>>(`${this.url}/unique-folios`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates a unique folio with the given data using the provided ID.\r\n   *\r\n   * @param {number} id - The ID of the unique folio to be updated.\r\n   * @param {UniqueFolioIn} body - The payload containing the details of the unique folio to update.\r\n   * @return {Observable<UniqueFolioOut>} An observable that emits the updated unique folio.\r\n   */\r\n  putUniqueFolio (id: number, body: UniqueFolioIn): Observable<UniqueFolioOut> {\r\n    return this.http.put<ApiSuccess<UniqueFolioOut>>(`${this.url}/unique-folios/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates a unique folio by its identifier with the provided data.\r\n   *\r\n   * @param {number} id - The identifier of the unique folio to update.\r\n   * @param {Partial<UniqueFolioIn>} body - The partial data of the unique folio to update.\r\n   * @return {Observable<UniqueFolioOut>} An observable emitting the updated unique folio data.\r\n   */\r\n  pathUniqueFolio (id: number, body: Partial<UniqueFolioIn>): Observable<UniqueFolioOut> {\r\n    return this.http.put<ApiSuccess<UniqueFolioOut>>(`${this.url}/unique-folios/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves shipment groups based on the provided query parameters.\r\n   *\r\n   * @param params - The query parameters to filter the shipment groups.\r\n   * @returns An Observable that emits the shipment groups data.\r\n   */\r\n  getShipmentGroups (params: QueryParams): Observable<ShipmentGroupsOut> {\r\n    return this.http.get<ApiSuccess<ShipmentGroupsOut>>(`${this.url}/shipment-groups`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the shipment statuses from the API.\r\n   *\r\n   * @param params - The query parameters to filter or modify the request.\r\n   * @returns An Observable that emits the shipment statuses output.\r\n   */\r\n  getShipmentStatuses (params: QueryParams): Observable<ShipmentStatusesOut> {\r\n    return this.http.get<ApiSuccess<ShipmentStatusesOut>>(`${this.url}/shipment-statuses`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches questions from the catalogs API.\r\n   *\r\n   * Sends an HTTP GET request to `${this.url}/questions` using the supplied query parameters\r\n   * and returns the unwrapped payload (`data`) from the API response.\r\n   *\r\n   * @param params - Query parameters to include in the request (e.g. paging, filters, sorting).\r\n   * @returns An Observable that emits the QuestionsOut payload (the `data` field from ApiSuccess<QuestionsOut>).\r\n   */\r\n  getQuestions (params: QueryParams): Observable<QuestionsOut> {\r\n    return this.http.get<ApiSuccess<QuestionsOut>>(`${this.url}/questions`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieve a single question by its id.\r\n   *\r\n   * Sends an HTTP GET request to the questions endpoint and returns an Observable that emits\r\n   * the QuestionOut payload extracted from the API success envelope.\r\n   *\r\n   * @param id - The numeric identifier of the question to fetch.\r\n   * @returns An Observable that emits the requested QuestionOut. The Observable will error\r\n   *          if the HTTP request fails (for example network issues or non-2xx responses).\r\n   */\r\n  getQuestion (id: number): Observable<QuestionOut> {\r\n    return this.http.get<ApiSuccess<QuestionOut>>(`${this.url}/questions/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a new question and returns the created resource.\r\n   *\r\n   * The request payload is sent as an object with a `body` property containing the provided\r\n   * QuestionIn value (i.e. { body: QuestionIn }). On success the HTTP response is expected\r\n   * to follow the ApiSuccess<T> shape; the operator maps that response to the inner `data`\r\n   * object and emits it as a QuestionOut.\r\n   *\r\n   * @param body - The question payload to create (QuestionIn).\r\n   * @returns Observable<QuestionOut> that emits the created question on success.\r\n   */\r\n  postQuestion (body: QuestionIn): Observable<QuestionOut> {\r\n    return this.http.post<ApiSuccess<QuestionOut>>(`${this.url}/questions`, { body })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Update a question by its ID.\r\n   *\r\n   * Sends an HTTP PUT to `${this.url}/questions/${id}` with the provided payload.\r\n   * The request body is sent as an object with a `body` property containing the\r\n   * `QuestionIn` data. The server response is expected to be an `ApiSuccess<QuestionOut>`\r\n   * and this method returns an Observable that emits the unwrapped `QuestionOut`.\r\n   *\r\n   * @param id - The identifier of the question to update.\r\n   * @param body - The update payload for the question.\r\n   * @returns An Observable that emits the updated `QuestionOut` on success.\r\n   */\r\n  putQuestion (id: number, body: QuestionIn): Observable<QuestionOut> {\r\n    return this.http.put<ApiSuccess<QuestionOut>>(`${this.url}/questions/${id}`, { body })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes a question by its ID.\r\n   *\r\n   * Sends an HTTP DELETE request to the backend endpoint `/questions/{id}` and\r\n   * returns an Observable that emits the API response's `data` payload (typically an empty object).\r\n   *\r\n   * The implementation maps an ApiSuccess wrapper to its `data` property before emitting.\r\n   *\r\n   * @param id - The numeric identifier of the question to delete.\r\n   * @returns An Observable that emits the deleted resource payload ({} expected) on success.\r\n   *          The Observable will emit an error if the HTTP request fails.\r\n   */\r\n  deleteQuestion (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/questions/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

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

@@ -346,6 +346,16 @@ export class ApiInvoicesService {
         return this.http.get(`${this.url}/operation/document/requests/${id}`)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Retrieves a list of documents based on the provided query parameters.
+     *
+     * @param params - The query parameters to filter and paginate the documents
+     * @returns An Observable that emits the documents data when the HTTP request completes
+     */
+    getDocuments(params) {
+        return this.http.get(`${this.url}/documents`, { params })
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInvoicesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInvoicesService, providedIn: 'root' });
 }
@@ -358,4 +368,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-invoices.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-invoices.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\nimport { map, Observable } from 'rxjs'\r\nimport { Environment } from '../ngx-services.models'\r\nimport {\r\n  CancelPaymentReceiptIn,\r\n  CountryPaymentTypeFieldIn,\r\n  CountryPaymentTypeFieldOut,\r\n  CountryPaymentTypeFieldsOut,\r\n  CountryPaymentTypeIn,\r\n  CountryPaymentTypeOut,\r\n  CountryPaymentTypesOut,\r\n  CustomerDocumentTypesOut,\r\n  CustomersOut,\r\n  CustomerTypesOut,\r\n  OperationAccountPaymentIn,\r\n  OperationAccountPaymentOut,\r\n  OperationCancelBillingIn,\r\n  OperationCancelBillingOut,\r\n  OperationDocumentIn,\r\n  OperationDocumentOut,\r\n  OperationDocumentRequestsOut,\r\n  OperationPrintDocumentOut,\r\n  OperationShipmentExternalIn,\r\n  OperationShipmentExternalOut,\r\n  PaymentTypeFieldAccountIn,\r\n  PaymentTypeFieldAccountOut,\r\n  PaymentTypeFieldAccountsOut,\r\n  PaymentTypeFieldCardTypeIn,\r\n  PaymentTypeFieldCardTypeOut,\r\n  PaymentTypeFieldCardTypesOut,\r\n  PaymentTypesOut,\r\n  PrintCollectionReceiptOut,\r\n  ToleranceIn,\r\n  ToleranceOut,\r\n  TolerancesOut,\r\n} from './models/api-invoices.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInvoicesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the API URL for invoices from the environments configuration.\r\n   *\r\n   * @return {string} The API URL for invoices.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInvoicesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Sends an operation document to the server and processes the response.\r\n   *\r\n   * @param {OperationDocumentIn} body - The input data for the operation document.\r\n   * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.\r\n   */\r\n  postOperationDocument (body: OperationDocumentIn): Observable<OperationDocumentOut> {\r\n    return this.http.post<ApiSuccess<OperationDocumentOut>>(`${this.url}/operation/document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches and returns the collection receipt data for a given collection ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.\r\n   * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.\r\n   */\r\n  getPrintCollectionReceipt (id: number): Observable<PrintCollectionReceiptOut> {\r\n    return this.http.get<ApiSuccess<PrintCollectionReceiptOut>>(`${this.url}/operation/print/collection-receipt/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Handles the account payment operation by sending a POST request to the specified endpoint.\r\n   * Processes the response and returns the operation data.\r\n   *\r\n   * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.\r\n   * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.\r\n   */\r\n  postOperationAccountPayment (body: OperationAccountPaymentIn): Observable<OperationAccountPaymentOut> {\r\n    return this.http.post<ApiSuccess<OperationAccountPaymentOut>>(`${this.url}/operation/account-payment`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels a payment receipt based on the provided input.\r\n   * This method sends a POST request to cancel a document.\r\n   *\r\n   * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.\r\n   * @return An Observable representing the result of the cancellation. Emits an empty object on success.\r\n   */\r\n  postOperationCancelDocument (body: CancelPaymentReceiptIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to cancel billing for a specific operation.\r\n   *\r\n   * @param {Object} params - The parameters for the cancellation request.\r\n   * @param {string} params.invoiceId - The ID of the invoice to be canceled.\r\n   * @param {Object} params.body - Additional data to be sent in the request body.\r\n   * @return {Observable<OperationCancelBillingOut>} An observable emitting the result of the cancellation operation.\r\n   */\r\n  postOperationCancelBilling ({ invoiceId, ...body }: OperationCancelBillingIn): Observable<OperationCancelBillingOut> {\r\n    return this.http.post<ApiSuccess<OperationCancelBillingOut>>(`${this.url}/operation/cancel-billing/${invoiceId}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of customer types from the server.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.\r\n   */\r\n  getCustomerTypes (params: QueryParams): Observable<CustomerTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerTypesOut>>(`${this.url}/customer-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves document types specific to a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters containing country-specific information.\r\n   * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.\r\n   */\r\n  getCustomerDocumentTypes (params: QueryParams): Observable<CustomerDocumentTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerDocumentTypesOut>>(`${this.url}/customer-country-document-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches customer invoice details filtered by a custom invoice type.\r\n   *\r\n   * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.\r\n   * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.\r\n   */\r\n  getCustomers (params: QueryParams): Observable<CustomersOut> {\r\n    return this.http.get<ApiSuccess<CustomersOut>>(`${this.url}/customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update an external shipment operation.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.\r\n   */\r\n  postOperationShipmentExternal (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Processes an external payment operation for a shipment.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.\r\n   */\r\n  postOperationShipmentExternalPayment (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external/payment`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns billing operation print details for a given document ID.\r\n   *\r\n   * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.\r\n   * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.\r\n   */\r\n  getOperationPrintDocument (documentId: number): Observable<OperationPrintDocumentOut> {\r\n    return this.http.get<ApiSuccess<OperationPrintDocumentOut>>(`${this.url}/operation/print/document/${documentId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all country payment types.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CountryPaymentTypesOut>} An observable emitting the country payment types fetched from the server.\r\n   */\r\n  getCountryPaymentTypes (params: QueryParams): Observable<CountryPaymentTypesOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypesOut>>(`${this.url}/country-payment-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing country payment type.\r\n   *\r\n   * @param {number} id - The ID of the country payment type to update.\r\n   * @param {CountryPaymentTypeIn} body - The updated data for the country payment type.\r\n   * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentType (id: number, body: CountryPaymentTypeIn): Observable<CountryPaymentTypeOut> {\r\n    return this.http.put<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing country payment type.\r\n   *\r\n   * @param {number} id - The unique identifier of the country payment type to be deleted.\r\n   * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the delete operation.\r\n   */\r\n  deleteCountryPaymentType (id: number): Observable<CountryPaymentTypeOut> {\r\n    return this.http.delete<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new country payment type resource.\r\n   *\r\n   * @param {CountryPaymentTypeIn} body - The input parameters required for create a new country payment type.\r\n   * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentType (body: CountryPaymentTypeIn): Observable<CountryPaymentTypeOut> {\r\n    return this.http.post<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns a country payment type for a given ID.\r\n   *\r\n   * @param {number} id - The ID of the country payment type.\r\n   * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of show operation.\r\n   */\r\n  getCountryPaymentType (id: number): Observable<CountryPaymentTypeOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all country payment type fields.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CountryPaymentTypeFieldsOut>} An observable emitting the country payment type fields fetched from the server.\r\n   */\r\n  getCountryPaymentTypeFields (params: QueryParams): Observable<CountryPaymentTypeFieldsOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypeFieldsOut>>(`${this.url}/country-payment-type-fields`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new country payment type field resource.\r\n   *\r\n   * @param {CountryPaymentTypeFieldIn} body - The input parameters required for create a new country payment type field.\r\n   * @return {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeField (body: CountryPaymentTypeFieldIn): Observable<CountryPaymentTypeFieldOut> {\r\n    return this.http.post<ApiSuccess<CountryPaymentTypeFieldOut>>(`${this.url}/country-payment-type-fields`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing country payment type field.\r\n   *\r\n   * @param {number} id - The ID of the country payment type field to update.\r\n   * @param {CountryPaymentTypeFieldIn} body - The updated data for the country payment type field.\r\n   * @returns {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeField (id: number, body: CountryPaymentTypeFieldIn): Observable<CountryPaymentTypeFieldOut> {\r\n    return this.http.put<ApiSuccess<CountryPaymentTypeFieldOut>>(`${this.url}/country-payment-type-fields/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment types.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypesOut>} An observable emitting the payment types fetched from the server.\r\n   */\r\n  getPaymentTypes (params: QueryParams): Observable<PaymentTypesOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypesOut>>(`${this.url}/payment-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment type fields card.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypeFieldCardTypesOut>} An observable emitting the payment type fields card fetched from the server.\r\n   */\r\n  getPaymentTypeFieldCardTypes (params: QueryParams): Observable<PaymentTypeFieldCardTypesOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypeFieldCardTypesOut>>(`${this.url}/payment-type-field-card-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new payment type field card resource.\r\n   *\r\n   * @param {PaymentTypeFieldCardTypeIn} body - The input parameters required for create a new payment type field card.\r\n   * @return {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeFieldCardType (body: PaymentTypeFieldCardTypeIn): Observable<PaymentTypeFieldCardTypeOut> {\r\n    return this.http.post<ApiSuccess<PaymentTypeFieldCardTypeOut>>(`${this.url}/payment-type-field-card-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing payment type field card.\r\n   *\r\n   * @param {number} id - The ID of the payment type field card to update.\r\n   * @param {PaymentTypeFieldCardTypeIn} body - The updated data for the payment type field card.\r\n   * @returns {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeFieldCardType (id: number, body: PaymentTypeFieldCardTypeIn): Observable<PaymentTypeFieldCardTypeOut> {\r\n    return this.http.put<ApiSuccess<PaymentTypeFieldCardTypeOut>>(`${this.url}/payment-type-field-card-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment type fields accounts.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypeFieldAccountsOut>} An observable emitting the payment type fields accounts fetched from the server.\r\n   */\r\n  getPaymentTypeFieldAccounts (params: QueryParams): Observable<PaymentTypeFieldAccountsOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypeFieldAccountsOut>>(`${this.url}/payment-type-field-accounts`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new payment type field account resource.\r\n   *\r\n   * @param {PaymentTypeFieldAccountIn} body - The input parameters required for create a new payment type field account.\r\n   * @return {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeFieldAccount (body: PaymentTypeFieldAccountIn): Observable<PaymentTypeFieldAccountOut> {\r\n    return this.http.post<ApiSuccess<PaymentTypeFieldAccountOut>>(`${this.url}/payment-type-field-accounts`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing payment type field account.\r\n   *\r\n   * @param {number} id - The ID of the payment type field account to update.\r\n   * @param {PaymentTypeFieldAccountIn} body - The updated data for the payment type field account.\r\n   * @returns {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeFieldAccount (id: number, body: PaymentTypeFieldAccountIn): Observable<PaymentTypeFieldAccountOut> {\r\n    return this.http.put<ApiSuccess<PaymentTypeFieldAccountOut>>(`${this.url}/payment-type-field-accounts/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches tolerance data from the server based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to use for querying tolerances.\r\n   * @return {Observable<TolerancesOut>} An observable emitting the tolerance data.\r\n   */\r\n  getTolerances (params: QueryParams): Observable<TolerancesOut> {\r\n    return this.http.get<ApiSuccess<TolerancesOut>>(`${this.url}/tolerances`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the tolerance detail for a given identifier.\r\n   *\r\n   * @param {number} id - The unique identifier for the tolerance to retrieve.\r\n   * @return {Observable<ToleranceOut>} An observable containing the tolerance data.\r\n   */\r\n  getTolerance (id: number): Observable<ToleranceOut> {\r\n    return this.http.get<ApiSuccess<ToleranceOut>>(`${this.url}/tolerances/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a request to update or create a tolerance record using the provided data.\r\n   *\r\n   * @param {ToleranceIn} body - The tolerance input object containing the data to be sent in the request.\r\n   * @return {Observable<ToleranceOut>} An observable that emits the updated or created tolerance output object.\r\n   */\r\n  postTolerance (body: ToleranceIn): Observable<ToleranceOut> {\r\n    return this.http.post<ApiSuccess<ToleranceOut>>(`${this.url}/tolerances`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the tolerance with the specified ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the tolerance to update.\r\n   * @param {ToleranceIn} body - The data to update the tolerance with.\r\n   * @return {Observable<ToleranceOut>} An observable containing the updated tolerance information.\r\n   */\r\n  putTolerance (id: number, body: ToleranceIn): Observable<ToleranceOut> {\r\n    return this.http.put<ApiSuccess<ToleranceOut>>(`${this.url}/tolerances/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes the tolerance entry corresponding to the given ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the tolerance to be deleted.\r\n   * @return {Observable<{}>} An Observable that emits the result of the delete operation.\r\n   */\r\n  deleteTolerance (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/tolerances/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the document requests associated with a document ID.\r\n   *\r\n   * @param id - The unique identifier for the document.\r\n   * @returns An observable that emits the document requests data.\r\n   */\r\n  getOperationDocumentRequests (id: number): Observable<OperationDocumentRequestsOut> {\r\n    return this.http.get<ApiSuccess<OperationDocumentRequestsOut>>(`${this.url}/operation/document/requests/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-invoices.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-invoices.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\nimport { map, Observable } from 'rxjs'\r\nimport { Environment } from '../ngx-services.models'\r\nimport {\r\n  CancelPaymentReceiptIn,\r\n  CountryPaymentTypeFieldIn,\r\n  CountryPaymentTypeFieldOut,\r\n  CountryPaymentTypeFieldsOut,\r\n  CountryPaymentTypeIn,\r\n  CountryPaymentTypeOut,\r\n  CountryPaymentTypesOut,\r\n  CustomerDocumentTypesOut,\r\n  CustomersOut,\r\n  CustomerTypesOut,\r\n  GetDocumentsOut,\r\n  OperationAccountPaymentIn,\r\n  OperationAccountPaymentOut,\r\n  OperationCancelBillingIn,\r\n  OperationCancelBillingOut,\r\n  OperationDocumentIn,\r\n  OperationDocumentOut,\r\n  OperationDocumentRequestsOut,\r\n  OperationPrintDocumentOut,\r\n  OperationShipmentExternalIn,\r\n  OperationShipmentExternalOut,\r\n  PaymentTypeFieldAccountIn,\r\n  PaymentTypeFieldAccountOut,\r\n  PaymentTypeFieldAccountsOut,\r\n  PaymentTypeFieldCardTypeIn,\r\n  PaymentTypeFieldCardTypeOut,\r\n  PaymentTypeFieldCardTypesOut,\r\n  PaymentTypesOut,\r\n  PrintCollectionReceiptOut,\r\n  ToleranceIn,\r\n  ToleranceOut,\r\n  TolerancesOut,\r\n} from './models/api-invoices.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInvoicesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the API URL for invoices from the environments configuration.\r\n   *\r\n   * @return {string} The API URL for invoices.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInvoicesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Sends an operation document to the server and processes the response.\r\n   *\r\n   * @param {OperationDocumentIn} body - The input data for the operation document.\r\n   * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.\r\n   */\r\n  postOperationDocument (body: OperationDocumentIn): Observable<OperationDocumentOut> {\r\n    return this.http.post<ApiSuccess<OperationDocumentOut>>(`${this.url}/operation/document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches and returns the collection receipt data for a given collection ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.\r\n   * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.\r\n   */\r\n  getPrintCollectionReceipt (id: number): Observable<PrintCollectionReceiptOut> {\r\n    return this.http.get<ApiSuccess<PrintCollectionReceiptOut>>(`${this.url}/operation/print/collection-receipt/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Handles the account payment operation by sending a POST request to the specified endpoint.\r\n   * Processes the response and returns the operation data.\r\n   *\r\n   * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.\r\n   * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.\r\n   */\r\n  postOperationAccountPayment (body: OperationAccountPaymentIn): Observable<OperationAccountPaymentOut> {\r\n    return this.http.post<ApiSuccess<OperationAccountPaymentOut>>(`${this.url}/operation/account-payment`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels a payment receipt based on the provided input.\r\n   * This method sends a POST request to cancel a document.\r\n   *\r\n   * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.\r\n   * @return An Observable representing the result of the cancellation. Emits an empty object on success.\r\n   */\r\n  postOperationCancelDocument (body: CancelPaymentReceiptIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to cancel billing for a specific operation.\r\n   *\r\n   * @param {Object} params - The parameters for the cancellation request.\r\n   * @param {string} params.invoiceId - The ID of the invoice to be canceled.\r\n   * @param {Object} params.body - Additional data to be sent in the request body.\r\n   * @return {Observable<OperationCancelBillingOut>} An observable emitting the result of the cancellation operation.\r\n   */\r\n  postOperationCancelBilling ({ invoiceId, ...body }: OperationCancelBillingIn): Observable<OperationCancelBillingOut> {\r\n    return this.http.post<ApiSuccess<OperationCancelBillingOut>>(`${this.url}/operation/cancel-billing/${invoiceId}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of customer types from the server.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.\r\n   */\r\n  getCustomerTypes (params: QueryParams): Observable<CustomerTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerTypesOut>>(`${this.url}/customer-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves document types specific to a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters containing country-specific information.\r\n   * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.\r\n   */\r\n  getCustomerDocumentTypes (params: QueryParams): Observable<CustomerDocumentTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerDocumentTypesOut>>(`${this.url}/customer-country-document-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches customer invoice details filtered by a custom invoice type.\r\n   *\r\n   * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.\r\n   * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.\r\n   */\r\n  getCustomers (params: QueryParams): Observable<CustomersOut> {\r\n    return this.http.get<ApiSuccess<CustomersOut>>(`${this.url}/customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update an external shipment operation.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.\r\n   */\r\n  postOperationShipmentExternal (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Processes an external payment operation for a shipment.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.\r\n   */\r\n  postOperationShipmentExternalPayment (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external/payment`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns billing operation print details for a given document ID.\r\n   *\r\n   * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.\r\n   * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.\r\n   */\r\n  getOperationPrintDocument (documentId: number): Observable<OperationPrintDocumentOut> {\r\n    return this.http.get<ApiSuccess<OperationPrintDocumentOut>>(`${this.url}/operation/print/document/${documentId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all country payment types.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CountryPaymentTypesOut>} An observable emitting the country payment types fetched from the server.\r\n   */\r\n  getCountryPaymentTypes (params: QueryParams): Observable<CountryPaymentTypesOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypesOut>>(`${this.url}/country-payment-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing country payment type.\r\n   *\r\n   * @param {number} id - The ID of the country payment type to update.\r\n   * @param {CountryPaymentTypeIn} body - The updated data for the country payment type.\r\n   * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentType (id: number, body: CountryPaymentTypeIn): Observable<CountryPaymentTypeOut> {\r\n    return this.http.put<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing country payment type.\r\n   *\r\n   * @param {number} id - The unique identifier of the country payment type to be deleted.\r\n   * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the delete operation.\r\n   */\r\n  deleteCountryPaymentType (id: number): Observable<CountryPaymentTypeOut> {\r\n    return this.http.delete<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new country payment type resource.\r\n   *\r\n   * @param {CountryPaymentTypeIn} body - The input parameters required for create a new country payment type.\r\n   * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentType (body: CountryPaymentTypeIn): Observable<CountryPaymentTypeOut> {\r\n    return this.http.post<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns a country payment type for a given ID.\r\n   *\r\n   * @param {number} id - The ID of the country payment type.\r\n   * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of show operation.\r\n   */\r\n  getCountryPaymentType (id: number): Observable<CountryPaymentTypeOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all country payment type fields.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CountryPaymentTypeFieldsOut>} An observable emitting the country payment type fields fetched from the server.\r\n   */\r\n  getCountryPaymentTypeFields (params: QueryParams): Observable<CountryPaymentTypeFieldsOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypeFieldsOut>>(`${this.url}/country-payment-type-fields`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new country payment type field resource.\r\n   *\r\n   * @param {CountryPaymentTypeFieldIn} body - The input parameters required for create a new country payment type field.\r\n   * @return {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeField (body: CountryPaymentTypeFieldIn): Observable<CountryPaymentTypeFieldOut> {\r\n    return this.http.post<ApiSuccess<CountryPaymentTypeFieldOut>>(`${this.url}/country-payment-type-fields`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing country payment type field.\r\n   *\r\n   * @param {number} id - The ID of the country payment type field to update.\r\n   * @param {CountryPaymentTypeFieldIn} body - The updated data for the country payment type field.\r\n   * @returns {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeField (id: number, body: CountryPaymentTypeFieldIn): Observable<CountryPaymentTypeFieldOut> {\r\n    return this.http.put<ApiSuccess<CountryPaymentTypeFieldOut>>(`${this.url}/country-payment-type-fields/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment types.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypesOut>} An observable emitting the payment types fetched from the server.\r\n   */\r\n  getPaymentTypes (params: QueryParams): Observable<PaymentTypesOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypesOut>>(`${this.url}/payment-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment type fields card.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypeFieldCardTypesOut>} An observable emitting the payment type fields card fetched from the server.\r\n   */\r\n  getPaymentTypeFieldCardTypes (params: QueryParams): Observable<PaymentTypeFieldCardTypesOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypeFieldCardTypesOut>>(`${this.url}/payment-type-field-card-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new payment type field card resource.\r\n   *\r\n   * @param {PaymentTypeFieldCardTypeIn} body - The input parameters required for create a new payment type field card.\r\n   * @return {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeFieldCardType (body: PaymentTypeFieldCardTypeIn): Observable<PaymentTypeFieldCardTypeOut> {\r\n    return this.http.post<ApiSuccess<PaymentTypeFieldCardTypeOut>>(`${this.url}/payment-type-field-card-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing payment type field card.\r\n   *\r\n   * @param {number} id - The ID of the payment type field card to update.\r\n   * @param {PaymentTypeFieldCardTypeIn} body - The updated data for the payment type field card.\r\n   * @returns {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeFieldCardType (id: number, body: PaymentTypeFieldCardTypeIn): Observable<PaymentTypeFieldCardTypeOut> {\r\n    return this.http.put<ApiSuccess<PaymentTypeFieldCardTypeOut>>(`${this.url}/payment-type-field-card-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment type fields accounts.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypeFieldAccountsOut>} An observable emitting the payment type fields accounts fetched from the server.\r\n   */\r\n  getPaymentTypeFieldAccounts (params: QueryParams): Observable<PaymentTypeFieldAccountsOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypeFieldAccountsOut>>(`${this.url}/payment-type-field-accounts`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new payment type field account resource.\r\n   *\r\n   * @param {PaymentTypeFieldAccountIn} body - The input parameters required for create a new payment type field account.\r\n   * @return {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeFieldAccount (body: PaymentTypeFieldAccountIn): Observable<PaymentTypeFieldAccountOut> {\r\n    return this.http.post<ApiSuccess<PaymentTypeFieldAccountOut>>(`${this.url}/payment-type-field-accounts`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing payment type field account.\r\n   *\r\n   * @param {number} id - The ID of the payment type field account to update.\r\n   * @param {PaymentTypeFieldAccountIn} body - The updated data for the payment type field account.\r\n   * @returns {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeFieldAccount (id: number, body: PaymentTypeFieldAccountIn): Observable<PaymentTypeFieldAccountOut> {\r\n    return this.http.put<ApiSuccess<PaymentTypeFieldAccountOut>>(`${this.url}/payment-type-field-accounts/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches tolerance data from the server based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to use for querying tolerances.\r\n   * @return {Observable<TolerancesOut>} An observable emitting the tolerance data.\r\n   */\r\n  getTolerances (params: QueryParams): Observable<TolerancesOut> {\r\n    return this.http.get<ApiSuccess<TolerancesOut>>(`${this.url}/tolerances`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the tolerance detail for a given identifier.\r\n   *\r\n   * @param {number} id - The unique identifier for the tolerance to retrieve.\r\n   * @return {Observable<ToleranceOut>} An observable containing the tolerance data.\r\n   */\r\n  getTolerance (id: number): Observable<ToleranceOut> {\r\n    return this.http.get<ApiSuccess<ToleranceOut>>(`${this.url}/tolerances/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a request to update or create a tolerance record using the provided data.\r\n   *\r\n   * @param {ToleranceIn} body - The tolerance input object containing the data to be sent in the request.\r\n   * @return {Observable<ToleranceOut>} An observable that emits the updated or created tolerance output object.\r\n   */\r\n  postTolerance (body: ToleranceIn): Observable<ToleranceOut> {\r\n    return this.http.post<ApiSuccess<ToleranceOut>>(`${this.url}/tolerances`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the tolerance with the specified ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the tolerance to update.\r\n   * @param {ToleranceIn} body - The data to update the tolerance with.\r\n   * @return {Observable<ToleranceOut>} An observable containing the updated tolerance information.\r\n   */\r\n  putTolerance (id: number, body: ToleranceIn): Observable<ToleranceOut> {\r\n    return this.http.put<ApiSuccess<ToleranceOut>>(`${this.url}/tolerances/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes the tolerance entry corresponding to the given ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the tolerance to be deleted.\r\n   * @return {Observable<{}>} An Observable that emits the result of the delete operation.\r\n   */\r\n  deleteTolerance (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/tolerances/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the document requests associated with a document ID.\r\n   *\r\n   * @param id - The unique identifier for the document.\r\n   * @returns An observable that emits the document requests data.\r\n   */\r\n  getOperationDocumentRequests (id: number): Observable<OperationDocumentRequestsOut> {\r\n    return this.http.get<ApiSuccess<OperationDocumentRequestsOut>>(`${this.url}/operation/document/requests/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of documents based on the provided query parameters.\r\n   *\r\n   * @param params - The query parameters to filter and paginate the documents\r\n   * @returns An Observable that emits the documents data when the HTTP request completes\r\n   */\r\n  getDocuments (params: QueryParams): Observable<GetDocumentsOut> {\r\n    return this.http.get<ApiSuccess<GetDocumentsOut>>(`${this.url}/documents`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

package/esm2022/lib/apis/models/api-catalog.interfaces.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-catalog.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-invoices.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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