@experteam-mx/ngx-services 18.3.5 → 18.3.7

package/esm2022/lib/apis/api-billing-do.service.mjs

@@ -0,0 +1,41 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiBillingDOService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the shipments API from the environment configurations.
+     *
+     * @return {string} The URL of the shipments API.
+     */
+    get url() {
+        return this.environments.apiBillingDO;
+    }
+    /**
+     * Retrieves a list of income types
+     *
+     * @return {Observable<ApiSuccess<IncomeTypesOut>>} An observable that emits the income types data.
+     */
+    getIncomeTypes() {
+        return this.http.get(`${this.url}/income-types`)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiBillingDOService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiBillingDOService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiBillingDOService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/apis/api-billing-mx.service.mjs

@@ -0,0 +1,62 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiBillingMxService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the shipments API from the environment configurations.
+     *
+     * @return {string} The URL of the shipments API.
+     */
+    get url() {
+        return this.environments.apiBillingMX;
+    }
+    /**
+     * Fetches the tax regimen data from the server.
+     *
+     * @return {Observable<FiscalRegimensOut>} An observable that emits the fiscal regimen data.
+     */
+    getFiscalRegimens() {
+        return this.http.get(`${this.url}/fiscal-regimens`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches a paginated list of CFDIs (Comprobante Fiscal Digital por Internet) based on the provided fiscal regimen.
+     *
+     * @param {number} fiscalRegimen - The fiscal regimen identifier to filter the CFDIs.
+     * @return {Observable<FiscalRegimensAcceptedOut>} An observable containing the paginated list of CFDIs.
+     */
+    getFiscalRegimensAccepted(fiscalRegimen) {
+        const params = { 'fiscal-regimen': fiscalRegimen };
+        return this.http.get(`${this.url}/cfdi-uses/fiscal-regimen-accepted/list`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches and validates postal code data from the server.
+     *
+     * @param {QueryParams} params - Query parameters used to filter the postal code data.
+     * @return {Observable<PostalCodesOut>} - An observable emitting the validated postal code data.
+     */
+    getPostalCodes(params) {
+        return this.http.get(`${this.url}/postal-codes`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiBillingMxService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiBillingMxService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiBillingMxService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,6 +1,5 @@
 import { Inject, Injectable } from '@angular/core';
 import { forkJoin, map, mergeMap } from 'rxjs';
-import { httpParams } from '../helpers/http';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
 export class ApiCompaniesService {
@@ -26,7 +25,7 @@ export class ApiCompaniesService {
      */
     getInstallations(params) {
         return this.http.get(`${this.url}/installations`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -47,7 +46,7 @@ export class ApiCompaniesService {
      */
     getLocations(params) {
         return this.http.get(`${this.url}/locations`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -64,11 +63,11 @@ export class ApiCompaniesService {
      * Retrieves a list of active supply entities.
      *
      * @param {QueryParams} params - The query parameters to filter supply entities.
-     * @return {Observable<SupplyEntitiesOut>} Observable emitting supply entities data.
+     * @return {Observable<SupplyEntitiesActivesOut>} Observable emitting supply entities data.
      */
-    getSupplyEntitiesActive(params) {
+    getSupplyEntitiesActives(params) {
         return this.http.get(`${this.url}/supply-entities/actives`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -79,7 +78,7 @@ export class ApiCompaniesService {
      */
     getEmployees(params) {
         return this.http.get(`${this.url}/employees`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -100,7 +99,7 @@ export class ApiCompaniesService {
      */
     getLocationEmployees(params) {
         return this.http.get(`${this.url}/location-employees`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -111,7 +110,7 @@ export class ApiCompaniesService {
      */
     getCompanyCountries(params) {
         return this.http.get(`${this.url}/company-countries`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -156,11 +155,11 @@ export class ApiCompaniesService {
      * Fetches exchange data based on the provided query parameters.
      *
      * @param {QueryParams} params - The query parameters for retrieving exchange data.
-     * @return {Observable<CountryExchangesOut>} An observable containing the exchange data.
+     * @return {Observable<ExchangesOut>} An observable containing the exchange data.
      */
     getExchanges(params) {
         return this.http.get(`${this.url}/exchanges`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -172,7 +171,7 @@ export class ApiCompaniesService {
      */
     getCurrentExchanges(params) {
         return this.http.get(`${this.url}/exchanges/current`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -183,18 +182,18 @@ export class ApiCompaniesService {
      */
     getCompanyCountryTaxes(params) {
         return this.http.get(`${this.url}/company-country-taxes`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
      * Retrieves the list of active account entities based on the provided query parameters.
      *
      * @param {QueryParams} params - The parameters to filter and query active account entities.
-     * @return {Observable<AccountEntitiesOut>} An observable that emits the list of active account entities.
+     * @return {Observable<AccountEntitiesActivesOut>} An observable that emits the list of active account entities.
      */
-    getActiveAccountEntities(params) {
+    getAccountEntitiesActives(params) {
         return this.http.get(`${this.url}/account-entities/actives`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -202,9 +201,9 @@ export class ApiCompaniesService {
      *
      * @param {Object} params - An object containing the required parameters.
      * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.
-     * @return {Observable<ParametersOut>} An observable that emits the fetched parameter values.
+     * @return {Observable<ParametersValuesOut>} An observable that emits the fetched parameter values.
      */
-    getParameters({ paramNames, }) {
+    getParametersValues({ paramNames, }) {
         const parameters = paramNames.map((p) => ({ name: p }));
         return this.http.post(`${this.url}/parameters-values`, {
             parameters
@@ -229,7 +228,7 @@ export class ApiCompaniesService {
      */
     getCountryReferences(params) {
         return this.http.get(`${this.url}/country-references`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     /**
@@ -250,7 +249,7 @@ export class ApiCompaniesService {
      */
     getWorkflows(params) {
         return this.http.get(`${this.url}/workflows`, {
-            params: httpParams(params),
+            params,
         }).pipe(map(({ data }) => data));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiCompaniesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -265,4 +264,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-companies.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 {\r\n  AccountEntitiesOut,\r\n  CompanyCountriesOut,\r\n  CompanyCountryOut,\r\n  CompanyCountryTaxesOut,\r\n  CountryExchangesOut,\r\n  CountryReferenceCurrenciesOut,\r\n  CountryReferenceOut,\r\n  CountryReferencesOut,\r\n  EmployeeOut,\r\n  EmployeesOut,\r\n  ExchangesOut,\r\n  InstallationOut,\r\n  InstallationsOut,\r\n  LocationEmployeesOut,\r\n  LocationOut,\r\n  LocationsOut,\r\n  ParametersIn,\r\n  ParametersOut,\r\n  ParameterValueIn,\r\n  ParameterValueOut,\r\n  SupplyEntitiesOut,\r\n  WorkflowsOut\r\n} from './models/api-companies.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport { forkJoin, map, mergeMap, Observable } from 'rxjs'\r\nimport { httpParams } from '../helpers/http'\r\nimport { CountryCurrencyRate } from './models/api-companies.interfaces'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCompaniesService {\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 companies API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the companies API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCompaniesUrl\r\n  }\r\n\r\n  /**\r\n   * Fetches the installations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter the installations query.\r\n   * @return {Observable<InstallationsOut>} An observable that emits the installation's data.\r\n   */\r\n  getInstallations (params: QueryParams): Observable<InstallationsOut> {\r\n    return this.http.get<ApiSuccess<InstallationsOut>>(`${this.url}/installations`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the installation details based on the given installation ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the installation to retrieve.\r\n   * @returns {Observable<InstallationOut>} An observable of the installation details.\r\n   */\r\n  getInstallation (id: number): Observable<InstallationOut> {\r\n    return this.http.get<ApiSuccess<InstallationOut>>(`${this.url}/installations/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of locations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to use for querying locations.\r\n   * @return {Observable<LocationsOut>} An observable that emits the location's data.\r\n   */\r\n  getLocations (params: QueryParams): Observable<LocationsOut> {\r\n    return this.http.get<ApiSuccess<LocationsOut>>(`${this.url}/locations`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the location details for a given location ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the location.\r\n   * @return {Observable<LocationOut>} An Observable containing the location details.\r\n   */\r\n  getLocation (id: number): Observable<LocationOut> {\r\n    return this.http.get<ApiSuccess<LocationOut>>(`${this.url}/locations/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of active supply entities.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter supply entities.\r\n   * @return {Observable<SupplyEntitiesOut>} Observable emitting supply entities data.\r\n   */\r\n  getSupplyEntitiesActive (params: QueryParams): Observable<SupplyEntitiesOut> {\r\n    return this.http.get<ApiSuccess<SupplyEntitiesOut>>(`${this.url}/supply-entities/actives`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of employees based on the specified query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and sort the employees.\r\n   * @return {Observable<EmployeesOut>} An observable that emits the list of employees.\r\n   */\r\n  getEmployees (params: QueryParams): Observable<EmployeesOut> {\r\n    return this.http.get<ApiSuccess<EmployeesOut>>(`${this.url}/employees`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches an employee's details based on the provided employee ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee.\r\n   * @return {Observable<EmployeeOut>} An observable that emits the employee's details.\r\n   */\r\n  getEmployee (id: number): Observable<EmployeeOut> {\r\n    return this.http.get<ApiSuccess<EmployeeOut>>(`${this.url}/employees/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of employees for a specified location based on provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and retrieve the location employees.\r\n   * @returns {Observable<LocationEmployeesOut>} An observable that emits the list of employees for the specified location.\r\n   */\r\n  getLocationEmployees (params: QueryParams): Observable<LocationEmployeesOut> {\r\n    return this.http.get<ApiSuccess<LocationEmployeesOut>>(`${this.url}/location-employees`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of countries where the company operates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for the API request.\r\n   * @return {Observable<CompanyCountriesOut>} An observable containing the list of company countries.\r\n   */\r\n  getCompanyCountries (params: QueryParams): Observable<CompanyCountriesOut> {\r\n    return this.http.get<ApiSuccess<CompanyCountriesOut>>(`${this.url}/company-countries`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the country information for a specified company by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the company.\r\n   * @return {Observable<CompanyCountryOut>} An observable containing the country information of the company.\r\n   */\r\n  getCompanyCountry (id: number): Observable<CompanyCountryOut> {\r\n    return this.http.get<ApiSuccess<CompanyCountryOut>>(`${this.url}/company-countries/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the reference currencies for a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to include in the request.\r\n   * @return {Observable<CountryReferenceCurrenciesOut>} The observable containing the country reference currencies data.\r\n   */\r\n  getCountryReferenceCurrencies (params: QueryParams): Observable<CountryReferenceCurrenciesOut> {\r\n    return this.http.get<ApiSuccess<CountryReferenceCurrenciesOut>>(\r\n      `${this.url}/country-reference-currencies`,\r\n      { params }\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of currencies for different countries along with their current exchange rates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.\r\n   * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.\r\n   */\r\n  getCountryCurrenciesWithRate (params: QueryParams): Observable<CountryCurrencyRate[]> {\r\n    return this.getCountryReferenceCurrencies(params)\r\n      .pipe(mergeMap((currenciesData) => {\r\n        const $observables = currenciesData.country_reference_currencies\r\n          .map((item) =>\r\n            this.getCurrentExchanges({\r\n              currency_id: item.currency.id,\r\n            }).pipe(\r\n              map((exchangesData) => ({\r\n                ...item,\r\n                rate: exchangesData.exchanges[0]?.value,\r\n              }))\r\n            )\r\n          )\r\n\r\n        return forkJoin($observables)\r\n      }))\r\n  }\r\n\r\n  /**\r\n   * Fetches exchange data based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for retrieving exchange data.\r\n   * @return {Observable<CountryExchangesOut>} An observable containing the exchange data.\r\n   */\r\n  getExchanges (params: QueryParams): Observable<CountryExchangesOut> {\r\n    return this.http.get<ApiSuccess<CountryExchangesOut>>(`${this.url}/exchanges`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the current exchanges based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the exchanges.\r\n   *\r\n   * @returns {Observable<ExchangesOut>} - An observable that emits the API response data containing the current exchanges.\r\n   */\r\n  getCurrentExchanges (params: QueryParams): Observable<ExchangesOut> {\r\n    return this.http.get<ApiSuccess<ExchangesOut>>(`${this.url}/exchanges/current`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country-specific tax information for a company.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter and query the taxes.\r\n   * @return {Observable<CompanyCountryTaxesOut>} An observable that emits the tax information.\r\n   */\r\n  getCompanyCountryTaxes (params: QueryParams): Observable<CompanyCountryTaxesOut> {\r\n    return this.http.get<ApiSuccess<CompanyCountryTaxesOut>>(`${this.url}/company-country-taxes`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of active account entities based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and query active account entities.\r\n   * @return {Observable<AccountEntitiesOut>} An observable that emits the list of active account entities.\r\n   */\r\n  getActiveAccountEntities (params: QueryParams): Observable<AccountEntitiesOut> {\r\n    return this.http.get<ApiSuccess<AccountEntitiesOut>>(`${this.url}/account-entities/actives`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the parameter values based on the provided parameter names.\r\n   *\r\n   * @param {Object} params - An object containing the required parameters.\r\n   * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.\r\n   * @return {Observable<ParametersOut>} An observable that emits the fetched parameter values.\r\n   */\r\n  getParameters ({\r\n    paramNames,\r\n  }: ParametersIn): Observable<ParametersOut> {\r\n    const parameters = paramNames.map((p) => ({ name: p }))\r\n\r\n    return this.http.post<ApiSuccess<ParametersOut>>(`${this.url}/parameters-values`, {\r\n      parameters\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the value of a specified parameter.\r\n   *\r\n   * @param {Object} input - The input object containing the parameter details.\r\n   * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.\r\n   * @return {Observable<ParameterValueOut>} An observable emitting the value of the specified parameter.\r\n   */\r\n  getParameterValue ({\r\n    paramName,\r\n  }: ParameterValueIn): Observable<ParameterValueOut> {\r\n    return this.http.get<ApiSuccess<ParameterValueOut>>(`${this.url}/parameters-values/${paramName}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of country references based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for retrieving country references.\r\n   * @return {Observable<CountryReferencesOut>} An observable containing the country reference data.\r\n   */\r\n  getCountryReferences (params: QueryParams): Observable<CountryReferencesOut> {\r\n    return this.http.get<ApiSuccess<CountryReferencesOut>>(`${this.url}/country-references`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country reference data for a given country ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.\r\n   * @return {Observable<CountryReferenceOut>} An observable containing the country reference data.\r\n   */\r\n  getCountryReference (id: number): Observable<CountryReferenceOut> {\r\n    return this.http.get<ApiSuccess<CountryReferenceOut>>(`${this.url}/country-references/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of workflows based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter workflows.\r\n   * @return {Observable<WorkflowsOut>} An observable containing the workflow data.\r\n   */\r\n  getWorkflows (params: QueryParams): Observable<WorkflowsOut> {\r\n    return this.http.get<ApiSuccess<WorkflowsOut>>(`${this.url}/workflows`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-companies.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 {\r\n  AccountEntitiesActivesOut,\r\n  CompanyCountriesOut,\r\n  CompanyCountryOut,\r\n  CompanyCountryTaxesOut,\r\n  CountryReferenceCurrenciesOut,\r\n  CountryReferenceOut,\r\n  CountryReferencesOut,\r\n  EmployeeOut,\r\n  EmployeesOut,\r\n  ExchangesOut,\r\n  InstallationOut,\r\n  InstallationsOut,\r\n  LocationEmployeesOut,\r\n  LocationOut,\r\n  LocationsOut,\r\n  ParametersIn,\r\n  ParametersValuesOut,\r\n  ParameterValueIn,\r\n  ParameterValueOut,\r\n  SupplyEntitiesActivesOut,\r\n  WorkflowsOut\r\n} from './models/api-companies.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport { forkJoin, map, mergeMap, Observable } from 'rxjs'\r\nimport { CountryCurrencyRate } from './models/api-companies.interfaces'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCompaniesService {\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 companies API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the companies API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCompaniesUrl\r\n  }\r\n\r\n  /**\r\n   * Fetches the installations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter the installations query.\r\n   * @return {Observable<InstallationsOut>} An observable that emits the installation's data.\r\n   */\r\n  getInstallations (params: QueryParams): Observable<InstallationsOut> {\r\n    return this.http.get<ApiSuccess<InstallationsOut>>(`${this.url}/installations`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the installation details based on the given installation ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the installation to retrieve.\r\n   * @returns {Observable<InstallationOut>} An observable of the installation details.\r\n   */\r\n  getInstallation (id: number): Observable<InstallationOut> {\r\n    return this.http.get<ApiSuccess<InstallationOut>>(`${this.url}/installations/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of locations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to use for querying locations.\r\n   * @return {Observable<LocationsOut>} An observable that emits the location's data.\r\n   */\r\n  getLocations (params: QueryParams): Observable<LocationsOut> {\r\n    return this.http.get<ApiSuccess<LocationsOut>>(`${this.url}/locations`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the location details for a given location ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the location.\r\n   * @return {Observable<LocationOut>} An Observable containing the location details.\r\n   */\r\n  getLocation (id: number): Observable<LocationOut> {\r\n    return this.http.get<ApiSuccess<LocationOut>>(`${this.url}/locations/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of active supply entities.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter supply entities.\r\n   * @return {Observable<SupplyEntitiesActivesOut>} Observable emitting supply entities data.\r\n   */\r\n  getSupplyEntitiesActives (params: QueryParams): Observable<SupplyEntitiesActivesOut> {\r\n    return this.http.get<ApiSuccess<SupplyEntitiesActivesOut>>(`${this.url}/supply-entities/actives`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of employees based on the specified query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and sort the employees.\r\n   * @return {Observable<EmployeesOut>} An observable that emits the list of employees.\r\n   */\r\n  getEmployees (params: QueryParams): Observable<EmployeesOut> {\r\n    return this.http.get<ApiSuccess<EmployeesOut>>(`${this.url}/employees`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches an employee's details based on the provided employee ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee.\r\n   * @return {Observable<EmployeeOut>} An observable that emits the employee's details.\r\n   */\r\n  getEmployee (id: number): Observable<EmployeeOut> {\r\n    return this.http.get<ApiSuccess<EmployeeOut>>(`${this.url}/employees/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of employees for a specified location based on provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and retrieve the location employees.\r\n   * @returns {Observable<LocationEmployeesOut>} An observable that emits the list of employees for the specified location.\r\n   */\r\n  getLocationEmployees (params: QueryParams): Observable<LocationEmployeesOut> {\r\n    return this.http.get<ApiSuccess<LocationEmployeesOut>>(`${this.url}/location-employees`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of countries where the company operates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for the API request.\r\n   * @return {Observable<CompanyCountriesOut>} An observable containing the list of company countries.\r\n   */\r\n  getCompanyCountries (params: QueryParams): Observable<CompanyCountriesOut> {\r\n    return this.http.get<ApiSuccess<CompanyCountriesOut>>(`${this.url}/company-countries`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the country information for a specified company by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the company.\r\n   * @return {Observable<CompanyCountryOut>} An observable containing the country information of the company.\r\n   */\r\n  getCompanyCountry (id: number): Observable<CompanyCountryOut> {\r\n    return this.http.get<ApiSuccess<CompanyCountryOut>>(`${this.url}/company-countries/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the reference currencies for a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to include in the request.\r\n   * @return {Observable<CountryReferenceCurrenciesOut>} The observable containing the country reference currencies data.\r\n   */\r\n  getCountryReferenceCurrencies (params: QueryParams): Observable<CountryReferenceCurrenciesOut> {\r\n    return this.http.get<ApiSuccess<CountryReferenceCurrenciesOut>>(\r\n      `${this.url}/country-reference-currencies`,\r\n      { params }\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of currencies for different countries along with their current exchange rates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.\r\n   * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.\r\n   */\r\n  getCountryCurrenciesWithRate (params: QueryParams): Observable<CountryCurrencyRate[]> {\r\n    return this.getCountryReferenceCurrencies(params)\r\n      .pipe(mergeMap((currenciesData) => {\r\n        const $observables = currenciesData.country_reference_currencies\r\n          .map((item) =>\r\n            this.getCurrentExchanges({\r\n              currency_id: item.currency.id,\r\n            }).pipe(\r\n              map((exchangesData) => ({\r\n                ...item,\r\n                rate: exchangesData.exchanges[0]?.value,\r\n              }))\r\n            )\r\n          )\r\n\r\n        return forkJoin($observables)\r\n      }))\r\n  }\r\n\r\n  /**\r\n   * Fetches exchange data based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for retrieving exchange data.\r\n   * @return {Observable<ExchangesOut>} An observable containing the exchange data.\r\n   */\r\n  getExchanges (params: QueryParams): Observable<ExchangesOut> {\r\n    return this.http.get<ApiSuccess<ExchangesOut>>(`${this.url}/exchanges`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the current exchanges based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the exchanges.\r\n   *\r\n   * @returns {Observable<ExchangesOut>} - An observable that emits the API response data containing the current exchanges.\r\n   */\r\n  getCurrentExchanges (params: QueryParams): Observable<ExchangesOut> {\r\n    return this.http.get<ApiSuccess<ExchangesOut>>(`${this.url}/exchanges/current`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country-specific tax information for a company.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter and query the taxes.\r\n   * @return {Observable<CompanyCountryTaxesOut>} An observable that emits the tax information.\r\n   */\r\n  getCompanyCountryTaxes (params: QueryParams): Observable<CompanyCountryTaxesOut> {\r\n    return this.http.get<ApiSuccess<CompanyCountryTaxesOut>>(`${this.url}/company-country-taxes`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of active account entities based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and query active account entities.\r\n   * @return {Observable<AccountEntitiesActivesOut>} An observable that emits the list of active account entities.\r\n   */\r\n  getAccountEntitiesActives (params: QueryParams): Observable<AccountEntitiesActivesOut> {\r\n    return this.http.get<ApiSuccess<AccountEntitiesActivesOut>>(`${this.url}/account-entities/actives`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the parameter values based on the provided parameter names.\r\n   *\r\n   * @param {Object} params - An object containing the required parameters.\r\n   * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.\r\n   * @return {Observable<ParametersValuesOut>} An observable that emits the fetched parameter values.\r\n   */\r\n  getParametersValues ({\r\n    paramNames,\r\n  }: ParametersIn): Observable<ParametersValuesOut> {\r\n    const parameters = paramNames.map((p) => ({ name: p }))\r\n\r\n    return this.http.post<ApiSuccess<ParametersValuesOut>>(`${this.url}/parameters-values`, {\r\n      parameters\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the value of a specified parameter.\r\n   *\r\n   * @param {Object} input - The input object containing the parameter details.\r\n   * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.\r\n   * @return {Observable<ParameterValueOut>} An observable emitting the value of the specified parameter.\r\n   */\r\n  getParameterValue ({\r\n    paramName,\r\n  }: ParameterValueIn): Observable<ParameterValueOut> {\r\n    return this.http.get<ApiSuccess<ParameterValueOut>>(`${this.url}/parameters-values/${paramName}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of country references based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for retrieving country references.\r\n   * @return {Observable<CountryReferencesOut>} An observable containing the country reference data.\r\n   */\r\n  getCountryReferences (params: QueryParams): Observable<CountryReferencesOut> {\r\n    return this.http.get<ApiSuccess<CountryReferencesOut>>(`${this.url}/country-references`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country reference data for a given country ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.\r\n   * @return {Observable<CountryReferenceOut>} An observable containing the country reference data.\r\n   */\r\n  getCountryReference (id: number): Observable<CountryReferenceOut> {\r\n    return this.http.get<ApiSuccess<CountryReferenceOut>>(`${this.url}/country-references/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of workflows based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter workflows.\r\n   * @return {Observable<WorkflowsOut>} An observable containing the workflow data.\r\n   */\r\n  getWorkflows (params: QueryParams): Observable<WorkflowsOut> {\r\n    return this.http.get<ApiSuccess<WorkflowsOut>>(`${this.url}/workflows`, {\r\n      params,\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

package/esm2022/lib/apis/api-external-pickups.service.mjs

@@ -0,0 +1,72 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiExternalPickupsService {
+    httpClient;
+    environment;
+    constructor(httpClient, environment) {
+        this.httpClient = httpClient;
+        this.environment = environment;
+    }
+    /**
+     * Getter method to retrieve the API's external operations URL.
+     * Fetches the URL from the `apiExternalOperationsUrl` property of the environment object.
+     * Defaults to an empty string if the property is undefined or null.
+     *
+     * @return {string} The external operations URL or an empty string if unavailable.
+     */
+    get url() {
+        return this.environment.apiExternalOperationsUrl ?? '';
+    }
+    /**
+     * Generates a delivery confirmation by sending the provided payload to the API.
+     *
+     * @param {DeliveryConfirmationGenerateIn} payload - The input payload required to generate the delivery confirmation.
+     * @return {Observable<DeliveryConfirmationGenerateOut>} An observable that emits the generated delivery confirmation data.
+     */
+    postDeliveryConfirmationGenerate(payload) {
+        return this.httpClient.post(`${this.url}/delivery-confirmation/generate`, payload, {
+            headers: { appkey: this.environment.apiExternalOperationsKey }
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Confirms the completion of a delivery operation by making a PATCH request.
+     *
+     * @param {Object} input - The input parameters for the method.
+     * @param {string} input.operationId - The unique identifier of the delivery operation to be confirmed.
+     * @param {string} input.keyOTP - The one-time password (OTP) key associated with the delivery confirmation.
+     * @return {Observable<Object>} - An observable containing the response data from the API.
+     */
+    patchDeliveryConfirmationComplete({ keyOTP, operationId, }) {
+        return this.httpClient.patch(`${this.url}/delivery-confirmation/completed/${keyOTP}`, null, {
+            headers: { appkey: this.environment.apiExternalOperationsKey },
+            params: { operation_id: operationId }
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Cancels a delivery confirmation by sending an OTP and additional data to the server.
+     *
+     * @param {Object} param0 - The parameter object containing the required properties.
+     * @param {string} param0.otp - The one-time password to authenticate the cancellation request.
+     * @param {Object} param0.body - Additional body data required for cancellation.
+     * @return {Observable<Object>} An observable that emits the server's response when the cancellation is processed.
+     */
+    putDeliveryConfirmation({ otp, ...body }) {
+        return this.httpClient.put(`${this.url}/delivery-confirmation/confirmation/${otp}`, body, {
+            headers: { appkey: this.environment.apiExternalOperationsKey },
+        }).pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiExternalPickupsService, deps: [{ token: i1.HttpClient }, { token: 'env' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiExternalPickupsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: ApiExternalPickupsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -23,7 +23,7 @@ export class ApiInvoicesService {
      * @param {OperationDocumentIn} body - The input data for the operation document.
      * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.
      */
-    operationDocument(body) {
+    postOperationDocument(body) {
         return this.http.post(`${this.url}/operation/document`, body)
             .pipe(map(({ data }) => data));
     }
@@ -31,9 +31,9 @@ export class ApiInvoicesService {
      * Fetches and returns the collection receipt data for a given collection ID.
      *
      * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.
-     * @return {Observable<CollectionReceiptOut>} An observable containing the collection receipt data.
+     * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.
      */
-    printCollectionReceipt(id) {
+    getPrintCollectionReceipt(id) {
         return this.http.get(`${this.url}/operation/print/collection-receipt/${id}`)
             .pipe(map(({ data }) => data));
     }
@@ -41,10 +41,10 @@ export class ApiInvoicesService {
      * Handles the account payment operation by sending a POST request to the specified endpoint.
      * Processes the response and returns the operation data.
      *
-     * @param {AccountPaymentOperationIn} body The payload containing information for the account payment operation.
-     * @return {Observable<AccountPaymentOperationOut>} An observable emitting the processed account payment operation data.
+     * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.
+     * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.
      */
-    accountPaymentOperation(body) {
+    postOperationAccountPayment(body) {
         return this.http.post(`${this.url}/operation/account-payment`, body)
             .pipe(map(({ data }) => data));
     }
@@ -55,7 +55,7 @@ export class ApiInvoicesService {
      * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.
      * @return An Observable representing the result of the cancellation. Emits an empty object on success.
      */
-    cancelPaymentReceipt(body) {
+    postOperationCancelDocument(body) {
         return this.http.post(`${this.url}/operation/cancel-document`, body)
             .pipe(map(({ data }) => data));
     }
@@ -65,10 +65,70 @@ export class ApiInvoicesService {
      * @param {Object} parameters - The parameters required to cancel the invoice, encapsulated in a CancelBillingIn object.
      * @return {Observable<Object>} An observable that emits the response of the cancellation operation.
      */
-    cancelInvoice({ invoiceId, ...body }) {
+    postOperationCancelBilling({ invoiceId, ...body }) {
         return this.http.post(`${this.url}/operation/cancel-billing/${invoiceId}`, body)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Fetches a list of customer types from the server.
+     *
+     * @param {QueryParams} params - Query parameters to filter or customize the request.
+     * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.
+     */
+    getCustomerTypes(params) {
+        return this.http.get(`${this.url}/customer-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves document types specific to a given country.
+     *
+     * @param {QueryParams} params - The query parameters containing country-specific information.
+     * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.
+     */
+    getCustomerDocumentTypes(params) {
+        return this.http.get(`${this.url}/customer-country-document-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches customer invoice details filtered by a custom invoice type.
+     *
+     * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.
+     * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.
+     */
+    getCustomers(params) {
+        return this.http.get(`${this.url}/customers`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update an external shipment operation.
+     *
+     * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.
+     * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.
+     */
+    postOperationShipmentExternal(params) {
+        return this.http.post(`${this.url}/operation/shipment/external`, params)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Processes an external payment operation for a shipment.
+     *
+     * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.
+     * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.
+     */
+    postOperationShipmentExternalPayment(params) {
+        return this.http.post(`${this.url}/operation/shipment/external/payment`, params)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves and returns billing operation print details for a given document ID.
+     *
+     * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.
+     * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.
+     */
+    getOperationPrintDocument(documentId) {
+        return this.http.get(`${this.url}/operation/print/document/${documentId}`)
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", 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.11", ngImport: i0, type: ApiInvoicesService, providedIn: 'root' });
 }
@@ -81,4 +141,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-invoices.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-invoices.service.ts"],"names":[],"mappings":"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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  CustomerDocumentTypesOut,\r\n  CustomersOut,\r\n  CustomerTypesOut,\r\n  InvoiceTypeCustomParamsIn,\r\n  OperationAccountPaymentIn,\r\n  OperationAccountPaymentOut,\r\n  OperationCancelBillingIn,\r\n  OperationDocumentIn,\r\n  OperationDocumentOut,\r\n  OperationPrintDocumentOut,\r\n  OperationShipmentExternalIn,\r\n  OperationShipmentExternalOut,\r\n  PrintCollectionReceiptOut\r\n} from './models/api-invoices.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInvoicesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the API URL for invoices from the environments configuration.\r\n   *\r\n   * @return {string} The API URL for invoices.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInvoicesUrl\r\n  }\r\n\r\n  /**\r\n   * Sends an operation document to the server and processes the response.\r\n   *\r\n   * @param {OperationDocumentIn} body - The input data for the operation document.\r\n   * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.\r\n   */\r\n  postOperationDocument (body: OperationDocumentIn): Observable<OperationDocumentOut> {\r\n    return this.http.post<ApiSuccess<OperationDocumentOut>>(`${this.url}/operation/document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches and returns the collection receipt data for a given collection ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.\r\n   * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.\r\n   */\r\n  getPrintCollectionReceipt (id: number): Observable<PrintCollectionReceiptOut> {\r\n    return this.http.get<ApiSuccess<PrintCollectionReceiptOut>>(`${this.url}/operation/print/collection-receipt/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Handles the account payment operation by sending a POST request to the specified endpoint.\r\n   * Processes the response and returns the operation data.\r\n   *\r\n   * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.\r\n   * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.\r\n   */\r\n  postOperationAccountPayment (body: OperationAccountPaymentIn): Observable<OperationAccountPaymentOut> {\r\n    return this.http.post<ApiSuccess<OperationAccountPaymentOut>>(`${this.url}/operation/account-payment`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels a payment receipt based on the provided input.\r\n   * This method sends a POST request to cancel a document.\r\n   *\r\n   * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.\r\n   * @return An Observable representing the result of the cancellation. Emits an empty object on success.\r\n   */\r\n  postOperationCancelDocument (body: CancelPaymentReceiptIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels an invoice based on the provided invoice ID and additional parameters.\r\n   *\r\n   * @param {Object} parameters - The parameters required to cancel the invoice, encapsulated in a CancelBillingIn object.\r\n   * @return {Observable<Object>} An observable that emits the response of the cancellation operation.\r\n   */\r\n  postOperationCancelBilling ({ invoiceId, ...body }: OperationCancelBillingIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-billing/${invoiceId}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of customer types from the server.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.\r\n   */\r\n  getCustomerTypes (params: QueryParams): Observable<CustomerTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerTypesOut>>(`${this.url}/customer-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves document types specific to a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters containing country-specific information.\r\n   * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.\r\n   */\r\n  getCustomerDocumentTypes (params: QueryParams): Observable<CustomerDocumentTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerDocumentTypesOut>>(`${this.url}/customer-country-document-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches customer invoice details filtered by a custom invoice type.\r\n   *\r\n   * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.\r\n   * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.\r\n   */\r\n  getCustomers (params: QueryParams): Observable<CustomersOut> {\r\n    return this.http.get<ApiSuccess<CustomersOut>>(`${this.url}/customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update an external shipment operation.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.\r\n   */\r\n  postOperationShipmentExternal (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Processes an external payment operation for a shipment.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.\r\n   */\r\n  postOperationShipmentExternalPayment (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external/payment`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns billing operation print details for a given document ID.\r\n   *\r\n   * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.\r\n   * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.\r\n   */\r\n  getOperationPrintDocument (documentId: number): Observable<OperationPrintDocumentOut> {\r\n    return this.http.get<ApiSuccess<OperationPrintDocumentOut>>(`${this.url}/operation/print/document/${documentId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}