@experteam-mx/ngx-services 18.4.0 → 18.4.2

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.13", 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.13", ngImport: i0, type: ApiBillingDOService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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.13", 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.13", ngImport: i0, type: ApiBillingMxService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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 {
@@ -16,7 +15,7 @@ export class ApiCompaniesService {
      * @return {string} The URL of the companies API.
      */
     get url() {
-        return this.environments.apiCompaniesUrl;
+        return this.environments.apiCompaniesUrl ?? '';
     }
     /**
      * Fetches the installations based on the provided query parameters.
@@ -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.13", 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.13", 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,74 @@
+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;
+    appKey;
+    constructor(httpClient, environment) {
+        this.httpClient = httpClient;
+        this.environment = environment;
+        this.appKey = environment.apiExternalOperationsKey ?? '';
+    }
+    /**
+     * 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.appKey }
+        }).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.appKey },
+            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.appKey },
+        }).pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", 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.13", ngImport: i0, type: ApiExternalPickupsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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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