@experteam-mx/ngx-services 20.0.0-beta.4 → 20.0.1

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

@@ -0,0 +1,1031 @@
+import { Inject, Injectable } from '@angular/core';
+import { forkJoin, map, mergeMap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiCompaniesService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the companies API from the environment configurations.
+     *
+     * @return {string} The URL of the companies API.
+     */
+    get url() {
+        return this.environments.apiCompaniesUrl ?? '';
+    }
+    /**
+     * Fetches the installations based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters used to filter the installations query.
+     * @return {Observable<InstallationsOut>} An observable that emits the installation's data.
+     */
+    getInstallations(params) {
+        return this.http.get(`${this.url}/installations`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the installation details based on the given installation ID.
+     *
+     * @param {number} id - The unique identifier of the installation to retrieve.
+     * @returns {Observable<InstallationOut>} An observable of the installation details.
+     */
+    getInstallation(id) {
+        return this.http.get(`${this.url}/installations/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a post-installation request to the server and retrieves the installation details.
+     *
+     * @param {InstallationIn} body - The installation details to be sent in the request body.
+     * @return {Observable<InstallationOut>} An observable that emits the response containing installation output details.
+     */
+    postInstallation(body) {
+        return this.http.post(`${this.url}/installations`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing installation record by its ID.
+     *
+     * @param id The unique identifier of the installation to update.
+     * @param body The data payload containing the updated installation information.
+     * @return An observable that emits the updated installation data upon a successful update.
+     */
+    putInstallation(id, body) {
+        return this.http.put(`${this.url}/installations/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes an installation by its unique identifier.
+     *
+     * @param {number} id - The unique identifier of the installation to be deleted.
+     * @return {Observable<{}>} An observable that emits the response after the installation is deleted.
+     */
+    deleteInstallation(id) {
+        return this.http.delete(`${this.url}/installations/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of locations based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters to use for querying locations.
+     * @return {Observable<LocationsOut>} An observable that emits the location's data.
+     */
+    getLocations(params) {
+        return this.http.get(`${this.url}/locations`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the location details for a given location ID.
+     *
+     * @param {number} id - The unique identifier of the location.
+     * @return {Observable<LocationOut>} An Observable containing the location details.
+     */
+    getLocation(id) {
+        return this.http.get(`${this.url}/locations/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a location object to the server and returns the created location data.
+     *
+     * @param {LocationIn} body - The location input object to be sent in the request body.
+     * @return {Observable<LocationOut>} An observable emitting the created location output object.
+     */
+    postLocation(body) {
+        return this.http.post(`${this.url}/locations`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the location information for the specified ID.
+     *
+     * @param {number} id - The unique identifier of the location to be updated.
+     * @param {LocationIn} body - The updated location data to be sent in the request body.
+     * @return {Observable<LocationOut>} An observable containing the updated location information.
+     */
+    putLocation(id, body) {
+        return this.http.put(`${this.url}/locations/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes a location by its unique identifier.
+     *
+     * @param {number} id - The unique identifier of the location to be deleted.
+     * @return {Observable<{}>} An observable that emits an empty object upon successful deletion.
+     */
+    deleteLocation(id) {
+        return this.http.delete(`${this.url}/locations/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * 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.
+     */
+    getSupplyEntitiesActives(params) {
+        return this.http.get(`${this.url}/supply-entities/actives`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves supply entities based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter and fetch the supply entities.
+     * @return {Observable<SupplyEntitiesOut>} An observable that emits the supply entities data.
+     */
+    getSupplyEntities(params) {
+        return this.http.get(`${this.url}/supply-entities`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends supply entities information to the server and receives the processed supply entities data in response.
+     *
+     * @param {SupplyEntitiesIn} body - The supply entities data to be sent to the server.
+     * @return {Observable<SupplyEntitiesOut>} An observable containing the processed supply entities data.
+     */
+    putSupplyEntities(body) {
+        return this.http.put(`${this.url}/supply-entities`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches a list of employees based on the specified query parameters.
+     *
+     * @param {QueryParams} params - The parameters to filter and sort the employees.
+     * @return {Observable<EmployeesOut>} An observable that emits the list of employees.
+     */
+    getEmployees(params) {
+        return this.http.get(`${this.url}/employees`, {
+            params,
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches an employee's details based on the provided employee ID.
+     *
+     * @param {number} id - The unique identifier of the employee.
+     * @return {Observable<EmployeeOut>} An observable that emits the employee's details.
+     */
+    getEmployee(id) {
+        return this.http.get(`${this.url}/employees/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create a new employee record.
+     *
+     * @param {EmployeeIn} body - The data of the employee to be created.
+     * @return {Observable<EmployeeOut>} An observable containing the created employee data.
+     */
+    postEmployee(body) {
+        return this.http.post(`${this.url}/employees`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing employee record with the specified data.
+     *
+     * @param {number} id - The unique identifier of the employee to be updated.
+     * @param {EmployeeIn} body - The employee data to update the record with.
+     * @return {Observable<EmployeeOut>} An observable containing the updated employee data.
+     */
+    putEmployee(id, body) {
+        return this.http.put(`${this.url}/employees/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes an employee based on the provided ID.
+     *
+     * @param {number} id - The unique identifier of the employee to delete.
+     * @return {Observable<{}>} An observable containing the response data after the employee is deleted.
+     */
+    deleteEmployee(id) {
+        return this.http.delete(`${this.url}/employees/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the list of employees for a specified location based on provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter and retrieve the location employees.
+     * @returns {Observable<LocationEmployeesOut>} An observable that emits the list of employees for the specified location.
+     */
+    getLocationEmployees(params) {
+        return this.http.get(`${this.url}/location-employees`, {
+            params,
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the location employee details for a given employee ID.
+     *
+     * @param {number} id - The unique identifier of the employee whose location details are to be retrieved.
+     * @return {Observable<LocationEmployeeOut>} An observable containing the location employee details.
+     */
+    getLocationEmployee(id) {
+        return this.http.get(`${this.url}/location-employees/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes a specific location employee by their unique identifier.
+     *
+     * @param {number} id - The unique identifier of the employee to be deleted.
+     * @return {Observable<{}>} - An observable emitting the server's response after the deletion.
+     */
+    deleteLocationEmployee(id) {
+        return this.http.delete(`${this.url}/location-employees/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a batch of location-employee associations to the server for processing.
+     *
+     * @param {LocationEmployeeBatchIn} body - The object containing a batch of location-employee data to be posted.
+     * @return {Observable<EmployeeOut>} An observable emitting the processed employee data from the server's response.
+     */
+    postLocationEmployeeBatch(body) {
+        return this.http.post(`${this.url}/location-employees/batch`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of countries where the company operates.
+     *
+     * @param {QueryParams} params - The query parameters for the API request.
+     * @return {Observable<CompanyCountriesOut>} An observable containing the list of company countries.
+     */
+    getCompanyCountries(params) {
+        return this.http.get(`${this.url}/company-countries`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the country information for a specified company by its ID.
+     *
+     * @param {number} id - The unique identifier of the company.
+     * @return {Observable<CompanyCountryOut>} An observable containing the country information of the company.
+     */
+    getCompanyCountry(id) {
+        return this.http.get(`${this.url}/company-countries/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a request to update or create a company country entry on the server.
+     *
+     * @param {CompanyCountryIn} body The data object representing the company country information to be sent to the server.
+     * @return {Observable<CompanyCountryOut>} An observable containing the server response with the updated or created company country data.
+     */
+    postCompanyCountry(body) {
+        return this.http.post(`${this.url}/company-countries`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the country information for a specific company.
+     *
+     * @param {number} id - The unique identifier of the company whose country information needs to be updated.
+     * @param {CompanyCountryIn} body - The updated country information to be applied to the company.
+     * @return {Observable<CompanyCountryOut>} An observable that emits the updated company country information.
+     */
+    putCompanyCountry(id, body) {
+        return this.http.put(`${this.url}/company-countries/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes a company-country association by its unique identifier.
+     *
+     * @param {number} id - The unique identifier of the company-country record to be deleted.
+     * @return {Observable<{}>} An observable emitting the result of the delete operation.
+     */
+    deleteCompanyCountry(id) {
+        return this.http.delete(`${this.url}/company-countries/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the reference currencies for a given country.
+     *
+     * @param {QueryParams} params - The query parameters to include in the request.
+     * @return {Observable<CountryReferenceCurrenciesOut>} The observable containing the country reference currencies data.
+     */
+    getCountryReferenceCurrencies(params) {
+        return this.http.get(`${this.url}/country-reference-currencies`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the reference currency details for a specific country using its ID.
+     *
+     * @param {number} id - The unique identifier of the country.
+     * @return {Observable<CountryReferenceCurrencyOut>} An observable emitting the country's reference currency details.
+     */
+    getCountryReferenceCurrency(id) {
+        return this.http.get(`${this.url}/country-reference-currencies/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of currencies for different countries along with their current exchange rates.
+     *
+     * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.
+     * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.
+     */
+    getCountryCurrenciesWithRate(params) {
+        return this.getCountryReferenceCurrencies(params)
+            .pipe(mergeMap((currenciesData) => {
+            const $observables = currenciesData.country_reference_currencies
+                .map((item) => this.getCurrentExchanges({
+                currency_id: item.currency.id,
+            }).pipe(map((exchangesData) => ({
+                ...item,
+                rate: exchangesData.exchanges[0]?.value,
+            }))));
+            return forkJoin($observables);
+        }));
+    }
+    /**
+     * Updates the reference currency for a specified country.
+     *
+     * @param {number} id - The unique identifier of the country.
+     * @param {CountryReferenceCurrencyIn} body - The data for updating the country's reference currency.
+     * @return {Observable<CountryReferenceCurrencyOut>} An Observable emitting the updated country reference currency data.
+     */
+    putCountryReferenceCurrency(id, body) {
+        return this.http.put(`${this.url}/country-reference-currencies/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create a country reference currency.
+     *
+     * @param {CountryReferenceCurrencyIn} body - The payload containing the country reference currency data.
+     * @return {Observable<CountryReferenceCurrencyOut>} An observable emitting the created country reference currency.
+     */
+    postCountryReferenceCurrency(body) {
+        return this.http.post(`${this.url}/country-reference-currencies`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update a country reference extra charge.
+     *
+     * @param {CountryReferenceExtraChargeIn} body - The request payload containing details about the country reference extra charge.
+     * @return {Observable<CountryReferenceExtraChargeOut>} An observable containing the response with the created or updated country reference extra charge.
+     */
+    postCountryReferenceExtraCharge(body) {
+        return this.http.post(`${this.url}/country-reference-extra-charges`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates a country reference extra charge by its ID.
+     *
+     * @param {number} id - The unique identifier of the country reference extra charge to be updated.
+     * @param {CountryReferenceExtraChargeIn} body - The data to update the country reference extra charge with.
+     * @return {Observable<CountryReferenceExtraChargeOut>} An observable that emits the updated country reference extra charge.
+     */
+    putCountryReferenceExtraCharge(id, body) {
+        return this.http.put(`${this.url}/country-reference-extra-charges/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Enables or disables a country reference extra charge based on the provided parameters.
+     *
+     * @param {CountryReferenceExtraCharge} extraCharge - The country reference extra charge object to be updated.
+     * @param {boolean} [isActive] - Optional parameter to explicitly set the active status of the extra charge.
+     *                               If not provided, the current active status will be toggled.
+     * @return {Observable<EmployeeCustomersOut>} An Observable that emits the updated employee customers output.
+     */
+    patchCountryReferenceExtraCharge(extraCharge, isActive) {
+        return this.http.patch(`${this.url}/country-reference-extra-charges/${extraCharge.id}`, {
+            is_active: isActive ?? !extraCharge.is_active
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches exchange data based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters for retrieving exchange data.
+     * @return {Observable<ExchangesOut>} An observable containing the exchange data.
+     */
+    getExchanges(params) {
+        return this.http.get(`${this.url}/exchanges`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update an exchange.
+     *
+     * @param {ExchangeIn} body - The request body containing the exchange data to be sent.
+     * @return {Observable<ExchangeOut>} An observable that emits the response containing the created or updated exchange data.
+     */
+    postExchange(body) {
+        return this.http.post(`${this.url}/exchanges`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing exchange with new data.
+     *
+     * @param {number} id - The unique identifier of the exchange to update.
+     * @param {ExchangeIn} body - The data to update the exchange with.
+     * @return {Observable<ExchangeOut>} An observable that emits the updated exchange data.
+     */
+    putExchange(id, body) {
+        return this.http.put(`${this.url}/exchanges/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the current exchanges based on the given query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the exchanges.
+     *
+     * @returns {Observable<ExchangesOut>} - An observable that emits the API response data containing the current exchanges.
+     */
+    getCurrentExchanges(params) {
+        return this.http.get(`${this.url}/exchanges/current`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the country-specific tax information for a company.
+     *
+     * @param {QueryParams} params - The parameters used to filter and query the taxes.
+     * @return {Observable<CompanyCountryTaxesOut>} An observable that emits the tax information.
+     */
+    getCompanyCountryTaxes(params) {
+        return this.http.get(`${this.url}/company-country-taxes`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches account information based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters for fetching account data.
+     * @return {Observable<AccountsOut>} An observable emitting the account data.
+     */
+    getAccounts(params) {
+        return this.http.get(`${this.url}/accounts`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the account information for the specified account ID.
+     *
+     * @param {number} id - The unique identifier of the account to retrieve.
+     * @return {Observable<AccountOut>} An observable that emits the account details.
+     */
+    getAccount(id) {
+        return this.http.get(`${this.url}/accounts/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new account by sending account details in the body.
+     *
+     * @param {AccountIn} body - The account information to be sent in the request body.
+     * @return {Observable<AccountOut>} Observable that emits the created account details upon success.
+     */
+    postAccount(body) {
+        return this.http.post(`${this.url}/accounts`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an account with the specified ID using the provided data.
+     *
+     * @param {number} id - The unique identifier of the account to be updated.
+     * @param {AccountIn} body - The data to update the account with.
+     * @return {Observable<AccountOut>} An observable emitting the updated account details.
+     */
+    putAccount(id, body) {
+        return this.http.put(`${this.url}/accounts/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches account entity data from the server based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to be sent with the HTTP request.
+     * @return {Observable<AccountEntitiesOut>} An observable that emits the account entities data.
+     */
+    getAccountEntities(params) {
+        return this.http.get(`${this.url}/account-entities`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an account entity using the provided details.
+     *
+     * @param {AccountEntitiesIn} body The account entity data to be updated.
+     * @return {Observable<AccountEntitiesOut>} An observable containing the updated account entity details.
+     */
+    putAccountEntity(body) {
+        return this.http.put(`${this.url}/account-entities`, body)
+            .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.
+     */
+    getAccountEntitiesActives(params) {
+        return this.http.get(`${this.url}/account-entities/actives`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches a list of account categories based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter the account categories.
+     * @return {Observable<AccountCategoriesOut>} An observable that emits the fetched account categories data.
+     */
+    getAccountCategories(params) {
+        return this.http.get(`${this.url}/account-categories`, { params, })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of account types from the server.
+     *
+     * @param {QueryParams} params - The query parameters to filter or customize the request.
+     * @return {Observable<AccountTypesOut>} An observable emitting the account types data.
+     */
+    getAccountTypes(params) {
+        return this.http.get(`${this.url}/account-types`, { params, })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the account type for the given account ID.
+     *
+     * @param {number} id - The unique identifier of the account.
+     * @return {Observable<AccountTypeOut>} An observable that emits the account type data.
+     */
+    getAccountType(id) {
+        return this.http.get(`${this.url}/account-types/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create a new account type.
+     *
+     * @param {AccountTypeIn} body - The data for the account type to be created.
+     * @return {Observable<AccountTypeOut>} An observable that emits the created account type object.
+     */
+    postAccountType(body) {
+        return this.http.post(`${this.url}/account-types`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an account type with the specified ID using the provided data.
+     *
+     * @param {number} id - The unique identifier of the account type to update.
+     * @param {AccountTypeIn} body - The data to update the account type with.
+     * @return {Observable<AccountTypeOut>} An observable containing the updated account type data.
+     */
+    putAccountType(id, body) {
+        return this.http.put(`${this.url}/account-types/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves parameters based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter or fetch the desired parameters.
+     * @return {Observable<ParametersOut>} An observable that emits the fetched parameters.
+     */
+    getParameters(params) {
+        return this.http.get(`${this.url}/parameters`, { params, })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the parameter values based on the provided parameter names.
+     *
+     * @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<ParametersValuesOut>} An observable that emits the fetched parameter values.
+     */
+    postParametersValues({ paramNames }) {
+        const parameters = paramNames.map((p) => ({ name: p }));
+        return this.http.post(`${this.url}/parameters-values`, { parameters })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves parameter values based on the provided level configuration.
+     *
+     * @param {ParametersByLevelIn} parameters - The input object containing the criteria or level details to retrieve the parameters.
+     * @return {Observable<ParametersValuesOut>} An observable that emits the parameter values fetched from the server.
+     */
+    postParameterValueByModel(parameters) {
+        return this.http.post(`${this.url}/parameters-values`, { parameters })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the value of a specified parameter.
+     *
+     * @param {Object} input - The input object containing the parameter details.
+     * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.
+     * @return {Observable<ParameterValueOut>} An observable emitting the value of the specified parameter.
+     */
+    getParameterValue({ paramName, }) {
+        return this.http.get(`${this.url}/parameters-values/${paramName}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of country references based on the given query parameters.
+     *
+     * @param {QueryParams} params - The query parameters for retrieving country references.
+     * @return {Observable<CountryReferencesOut>} An observable containing the country reference data.
+     */
+    getCountryReferences(params) {
+        return this.http.get(`${this.url}/country-references`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the country reference data for a given country ID.
+     *
+     * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.
+     * @return {Observable<CountryReferenceOut>} An observable containing the country reference data.
+     */
+    getCountryReference(id) {
+        return this.http.get(`${this.url}/country-references/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates a country reference resource with the specified ID and data.
+     *
+     * @param {number} id - The unique identifier of the country reference to be updated.
+     * @param {CountryReferenceIn} body - The data to update the country reference with.
+     * @return {Observable<CountryReferenceOut>} An observable that emits the updated country reference object.
+     */
+    putCountryReference(id, body) {
+        return this.http.put(`${this.url}/country-references/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the list of workflows based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter workflows.
+     * @return {Observable<WorkflowsOut>} An observable containing the workflow data.
+     */
+    getWorkflows(params) {
+        return this.http.get(`${this.url}/workflows`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the list of employee customer
+     *
+     * @param {QueryParams} params - The query parameters used to filter employee customers.
+     * @return {Observable<EmployeeCustomersOut>} An observable containing the employee customer data.
+     */
+    getEmployeesCustomers(params) {
+        return this.http.get(`${this.url}/employee-customers`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update employee customer records and processes the server response.
+     *
+     * @param {EmployeeCustomersIn} body - The request payload containing employee customer data to be sent to the server.
+     * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee customer data on successful response.
+     */
+    postEmployeeCustomers(body) {
+        return this.http.post(`${this.url}/employee-customers`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the employee-customer association record identified by the given ID with the provided data.
+     *
+     * @param {number} id - The identifier of the employee-customer record to update.
+     * @param {EmployeeCustomersIn} body - The data to update the employee-customer record with.
+     * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee-customer data.
+     */
+    putEmployeeCustomers(id, body) {
+        return this.http.put(`${this.url}/employee-customers/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the employee-customer details based on the provided employee customer ID.
+     *
+     * @param {number} id - The identifier of the employee-customer record to update.
+     * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee-customer data.
+     */
+    getEmployeeCustomer(id) {
+        return this.http.get(`${this.url}/employee-customers/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Enables or disables an employee customer's active state.
+     *
+     * @param {EmployeeCustomerDhl} employee - The employee customer object to be updated.
+     * @param {boolean} [isActive] - Optional parameter to explicitly set the active state.
+     *                                If null or undefined, the active state will be toggled.
+     * @return {Observable<EmployeeCustomersOut>} An observable containing the updated employee customer output.
+     */
+    patchEmployeeCustomers(employee, isActive) {
+        return this.http.patch(`${this.url}/employee-customers/${employee.id}`, {
+            is_active: isActive ?? !employee.is_active
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Submits a file containing employee customer data for a specific country to the server.
+     *
+     * @param {number} countryId - The identifier of the country for which the data is being uploaded.
+     * @param {File} file - The file contains employee customer data to be uploaded.
+     * @return {Observable<BoardingProcessIdIn>} Observable that emits the processed boarding process ID on success.
+     */
+    postEmployeeCustomersLoad(countryId, file) {
+        const body = new FormData();
+        body.append('file', file);
+        body.append('country_id', countryId.toString());
+        return this.http.post(`${this.url}/employee-customers/load`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Downloads a file containing customer data for a specific employee based on the provided country ID.
+     *
+     * @param {number} id - The ID of the country used as a filter for fetching the employee's customers.
+     * @return {Observable<Blob>} An observable that emits the file blob containing the customer data.
+     */
+    getEmployeeCustomersDownload(id) {
+        return this.http.get(`${this.url}/employee-customers/download`, {
+            params: { country_id: id },
+            responseType: 'blob'
+        });
+    }
+    /**
+     * Retrieves the boarding process details for a given ID.
+     *
+     * @param {number} id - The unique identifier of the boarding process to retrieve.
+     * @return {Observable<BoardingProcessIn>} An observable containing the boarding process details.
+     */
+    getBoardingProcess(id) {
+        return this.http.get(`${this.url}/boarding-process/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches a list of systems based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters used to filter the systems.
+     * @return {Observable<SystemsOut>} An observable that emits the retrieved systems data.
+     */
+    getSystems(params) {
+        return this.http.get(`${this.url}/systems`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the system by the specified ID.
+     *
+     * @param {number} id - The unique identifier of the system to be retrieved.
+     * @return {Observable<SystemOut>} An observable that emits the requested system information.
+     */
+    getSystem(id) {
+        return this.http.get(`${this.url}/systems/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update a system.
+     *
+     * @param {SystemIn} body - The data representing the system to be created or updated.
+     * @return {Observable<SystemOut>} An observable emitting the resulting system output after the API request succeeds.
+     */
+    postSystem(body) {
+        return this.http.post(`${this.url}/systems`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the system identified by the given ID with the provided request body and returns the updated system details.
+     *
+     * @param {number} id - The unique identifier of the system to be updated.
+     * @param {SystemIn} body - The payload containing the updated system details.
+     * @return {Observable<SystemOut>} An observable emitting the updated system data.
+     */
+    putSystem(id, body) {
+        return this.http.put(`${this.url}/systems/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of system entities based on the specified query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter or specify the system entities to retrieve.
+     * @return {Observable<SystemEntitiesOut>} An Observable that emits the retrieved system entities.
+     */
+    getSystemEntities(params) {
+        return this.http.get(`${this.url}/system-entities`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the system entities by sending the provided data to the server.
+     *
+     * @param {SystemEntitiesIn} body - The data object representing the system entities to be updated.
+     * @return {Observable<SystemEntitiesOut>} An observable containing the updated system entities data.
+     */
+    putSystemEntities(body) {
+        return this.http.put(`${this.url}/system-entities`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves workflow configurations based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the workflow configurations.
+     * @return {Observable<WorkflowConfigsOut>} An observable emitting the workflow configurations.
+     */
+    getWorkflowConfigs(params) {
+        return this.http.get(`${this.url}/workflow-configs`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a batch of workflow configuration data to the server for processing.
+     *
+     * @param {WorkflowConfigsBatchIn} body - The input data containing a batch of workflow configurations to be sent.
+     * @return {Observable<WorkflowConfigsOut>} An observable that emits the processed batch of workflow configuration data as a response.
+     */
+    postWorkflowConfigsBatch(body) {
+        return this.http.post(`${this.url}/workflow-configs/batch`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create a new company and returns the created company's details.
+     *
+     * @param {CompanyIn} body - The payload containing the details of the company to be created.
+     * @return {Observable<CompanyOut>} An Observable emitting the response with the created company's details.
+     */
+    postCompany(body) {
+        return this.http.post(`${this.url}/companies`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the details of an existing company using its ID.
+     *
+     * @param {number} id - The unique identifier of the company to update.
+     * @param {CompanyIn} body - The object containing the updated company data.
+     * @return {Observable<CompanyOut>} An observable that emits the updated company details.
+     */
+    putCompany(id, body) {
+        return this.http.put(`${this.url}/companies/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes a company by its unique identifier.
+     *
+     * @param {number} id - The unique identifier of the company to be deleted.
+     * @return {Observable<{}>} An observable that emits an empty object upon successful deletion or an error if the operation fails.
+     */
+    deleteCompany(id) {
+        return this.http.delete(`${this.url}/companies/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches product entities from the server based on the provided query parameters.
+     *
+     * @param {QueryParams} params The query parameters used to modify the request for product entities.
+     * @return {Observable<ProductEntitiesOut>} An observable that emits the product entities retrieved from the server.
+     */
+    getProductEntities(params) {
+        return this.http.get(`${this.url}/product-entities`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a PUT request to update product entities and returns the updated entity.
+     *
+     * @param {ProductEntitiesIn} body - The payload containing the data to update the product entity.
+     * @return {Observable<ProductEntitiesOut>} Observable that emits the updated product entity.
+     */
+    putProductEntities(body) {
+        return this.http.put(`${this.url}/product-entities`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the country reference products based on the given query parameters.
+     *
+     * @param {QueryParams} params The query parameters used to filter and retrieve the country reference products.
+     * @return {Observable<CountryReferenceProductsOut>} An observable emitting the fetched country reference products data.
+     */
+    getCountryReferenceProducts(params) {
+        return this.http.get(`${this.url}/country-reference-products`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a request to update or create country reference products.
+     *
+     * @param {CountryReferenceProductIn} body - The payload containing the details of the country reference products to post.
+     * @return {Observable<CountryReferenceProductOut>} An observable that emits the updated or created country reference product data.
+     */
+    postCountryReferenceProducts(body) {
+        return this.http.post(`${this.url}/country-reference-products`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates a country reference product with the specified ID using the provided data.
+     *
+     * @param {number} id - The unique identifier of the country reference product to update.
+     * @param {CountryReferenceProductIn} body - The updated country reference product data to be sent in the request body.
+     * @return {Observable<CountryReferenceProductOut>} An observable emitting the updated country reference product.
+     */
+    putCountryReferenceProducts(id, body) {
+        return this.http.put(`${this.url}/country-reference-products/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the extra charge entities from the server based on the provided query parameters.
+     *
+     * @param {QueryParams} params - An object containing the query parameters to filter the extra charge entities.
+     * @return {Observable<ExtraChargeEntitiesOut>} An observable that emits the extra charge entities retrieved from the server.
+     */
+    getExtraChargeEntities(params) {
+        return this.http.get(`${this.url}/extracharge-entities`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates extra charge entities by sending the provided data to the server.
+     *
+     * @param {ExtraChargeEntitiesIn} body - The data to update the extra charge entities.
+     * @return {Observable<ExtraChargeEntitiesOut>} An observable that emits the updated extra charge entities.
+     */
+    putExtraChargeEntities(body) {
+        return this.http.put(`${this.url}/extracharge-entities`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the parameter configurations based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the parameter configurations.
+     * @return {Observable<ParameterConfigsOut>} An observable that emits the parameter configurations data.
+     */
+    getParameterConfigs(params) {
+        return this.http.get(`${this.url}/parameter-configs`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update a parameter configuration.
+     *
+     * @param {ParameterConfigIn} body - The input data object containing the parameter configuration to be sent in the request body.
+     * @return {Observable<ParameterConfigOut>} An observable that emits the server's response containing the updated or newly created parameter configuration.
+     */
+    postParameterConfig(body) {
+        return this.http.post(`${this.url}/parameter-configs`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the configuration of a parameter with the provided ID and input data.
+     *
+     * @param {number} id - The unique identifier of the parameter configuration to be updated.
+     * @param {ParameterConfigIn} body - The input data containing the updated configuration for the parameter.
+     * @return {Observable<ParameterConfigOut>} An observable that emits the updated parameter configuration.
+     */
+    putParameterConfig(id, body) {
+        return this.http.put(`${this.url}/parameter-configs/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Deletes a parameter configuration specified by its ID.
+     *
+     * @param {number} id - The unique identifier of the parameter configuration to be deleted.
+     * @return {Observable<ParameterConfigOut>} An observable containing the deleted parameter configuration data.
+     */
+    deleteParameterConfig(id) {
+        return this.http.delete(`${this.url}/parameter-configs/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of TDX account settings based on the given query parameters.
+     *
+     * @param {QueryParams} params - Query parameters used to filter or paginate the results.
+     * @returns {Observable<TDXAccountsSettingsOut>} An observable containing the list of TDX account settings.
+     */
+    getTDXAccountsSettings(params) {
+        return this.http.get(`${this.url}/tdx-account-settings`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a single TDX account setting by its ID.
+     *
+     * @param {number} id - The unique identifier of the TDX account setting to be retrieved.
+     * @returns {Observable<TDXAccountSettingsOut>} An observable containing the requested TDX account setting.
+     */
+    getTDXAccountSettings(id) {
+        return this.http.get(`${this.url}/tdx-account-settings/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new TDX account setting with the provided data.
+     *
+     * @param {TDXAccountSettingsIn} body - The data used to create the new TDX account setting.
+     * @returns {Observable<TDXAccountSettingsOut>} An observable containing the newly created TDX account setting.
+     */
+    postTDXAccountSettings(body) {
+        return this.http.post(`${this.url}/tdx-account-settings`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing TDX account setting identified by its ID.
+     *
+     * @param {number} id - The unique identifier of the TDX account setting to be updated.
+     * @param {TDXAccountSettingsIn} body - The updated data for the TDX account setting.
+     * @returns {Observable<TDXAccountSettingsOut>} An observable containing the updated TDX account setting.
+     */
+    putTDXAccountSettings(id, body) {
+        return this.http.put(`${this.url}/tdx-account-settings/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the employees of a specific location using a provided token.
+     *
+     * @param params - Input parameters for the request, defined by the `LocationEmployeesIn` interface.
+     * @returns An `Observable<LocationEmployeesOut>` that emits the employees
+     * associated with the given location.
+     * @returns The response type is `ApiSuccess<LocationEmployeesOut>`, from which the `data` field is extracted.
+     */
+    getLocationEmployeesByToken(params) {
+        return this.http.get(`${this.url}/location-employees`, {
+            params: params.queryParams,
+            headers: {
+                Authorization: `Bearer ${params.token}`
+            }
+        }).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 });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCompaniesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCompaniesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    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  AccountCategoriesOut,\r\n  AccountEntitiesIn,\r\n  AccountEntitiesOut,\r\n  AccountIn,\r\n  AccountOut,\r\n  AccountsOut,\r\n  AccountTypeIn,\r\n  AccountTypeOut,\r\n  AccountTypesOut,\r\n  BoardingProcessIdIn,\r\n  BoardingProcessIn,\r\n  CompanyCountriesOut,\r\n  CompanyCountryIn,\r\n  CompanyCountryOut,\r\n  CompanyCountryTaxesOut,\r\n  CompanyIn,\r\n  CompanyOut,\r\n  CountryReferenceCurrenciesOut,\r\n  CountryReferenceCurrencyIn,\r\n  CountryReferenceCurrencyOut,\r\n  CountryReferenceExtraChargeIn,\r\n  CountryReferenceExtraChargeOut,\r\n  CountryReferenceIn,\r\n  CountryReferenceOut,\r\n  CountryReferenceProductIn,\r\n  CountryReferenceProductOut,\r\n  CountryReferenceProductsOut,\r\n  CountryReferencesOut,\r\n  EmployeeCustomersIn,\r\n  EmployeeCustomersOut,\r\n  EmployeeIn,\r\n  EmployeeOut,\r\n  EmployeesCustomersOut,\r\n  EmployeesOut,\r\n  ExchangeIn,\r\n  ExchangeOut,\r\n  ExchangesOut,\r\n  ExtraChargeEntitiesIn,\r\n  ExtraChargeEntitiesOut,\r\n  InstallationIn,\r\n  InstallationOut,\r\n  InstallationsOut,\r\n  LocationEmployeeBatchIn,\r\n  LocationEmployeeOut, LocationEmployeesIn,\r\n  LocationEmployeesOut,\r\n  LocationIn,\r\n  LocationOut,\r\n  LocationsOut,\r\n  ParameterConfigIn,\r\n  ParameterConfigOut,\r\n  ParameterConfigsOut,\r\n  ParametersByLevelIn,\r\n  ParametersOut,\r\n  ParametersValuesIn,\r\n  ParametersValuesOut,\r\n  ParameterValueIn,\r\n  ParameterValueOut,\r\n  ProductEntitiesIn,\r\n  ProductEntitiesOut,\r\n  SupplyEntitiesIn,\r\n  SupplyEntitiesOut,\r\n  SystemEntitiesIn,\r\n  SystemEntitiesOut,\r\n  SystemIn,\r\n  SystemOut,\r\n  SystemsOut,\r\n  TDXAccountSettingsIn,\r\n  TDXAccountSettingsOut,\r\n  TDXAccountsSettingsOut,\r\n  WorkflowConfigsBatchIn,\r\n  WorkflowConfigsOut,\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 {\r\n  CountryCurrencyRate,\r\n  CountryReferenceExtraCharge,\r\n  EmployeeCustomerDhl,\r\n} 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`, { 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   * Sends a post-installation request to the server and retrieves the installation details.\r\n   *\r\n   * @param {InstallationIn} body - The installation details to be sent in the request body.\r\n   * @return {Observable<InstallationOut>} An observable that emits the response containing installation output details.\r\n   */\r\n  postInstallation (body: InstallationIn): Observable<InstallationOut> {\r\n    return this.http.post<ApiSuccess<InstallationOut>>(`${this.url}/installations`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing installation record by its ID.\r\n   *\r\n   * @param id The unique identifier of the installation to update.\r\n   * @param body The data payload containing the updated installation information.\r\n   * @return An observable that emits the updated installation data upon a successful update.\r\n   */\r\n  putInstallation (id: number, body: InstallationIn): Observable<InstallationOut> {\r\n    return this.http.put<ApiSuccess<InstallationOut>>(`${this.url}/installations/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes an installation by its unique identifier.\r\n   *\r\n   * @param {number} id - The unique identifier of the installation to be deleted.\r\n   * @return {Observable<{}>} An observable that emits the response after the installation is deleted.\r\n   */\r\n  deleteInstallation (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${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`, { 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   * Sends a location object to the server and returns the created location data.\r\n   *\r\n   * @param {LocationIn} body - The location input object to be sent in the request body.\r\n   * @return {Observable<LocationOut>} An observable emitting the created location output object.\r\n   */\r\n  postLocation (body: LocationIn): Observable<LocationOut> {\r\n    return this.http.post<ApiSuccess<LocationOut>>(`${this.url}/locations`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the location information for the specified ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the location to be updated.\r\n   * @param {LocationIn} body - The updated location data to be sent in the request body.\r\n   * @return {Observable<LocationOut>} An observable containing the updated location information.\r\n   */\r\n  putLocation (id: number, body: LocationIn): Observable<LocationOut> {\r\n    return this.http.put<ApiSuccess<LocationOut>>(`${this.url}/locations/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes a location by its unique identifier.\r\n   *\r\n   * @param {number} id - The unique identifier of the location to be deleted.\r\n   * @return {Observable<{}>} An observable that emits an empty object upon successful deletion.\r\n   */\r\n  deleteLocation (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${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  getSupplyEntitiesActives (params: QueryParams): Observable<SupplyEntitiesOut> {\r\n    return this.http.get<ApiSuccess<SupplyEntitiesOut>>(`${this.url}/supply-entities/actives`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves supply entities based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and fetch the supply entities.\r\n   * @return {Observable<SupplyEntitiesOut>} An observable that emits the supply entities data.\r\n   */\r\n  getSupplyEntities (params: QueryParams): Observable<SupplyEntitiesOut> {\r\n    return this.http.get<ApiSuccess<SupplyEntitiesOut>>(`${this.url}/supply-entities`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends supply entities information to the server and receives the processed supply entities data in response.\r\n   *\r\n   * @param {SupplyEntitiesIn} body - The supply entities data to be sent to the server.\r\n   * @return {Observable<SupplyEntitiesOut>} An observable containing the processed supply entities data.\r\n   */\r\n  putSupplyEntities (body: SupplyEntitiesIn): Observable<SupplyEntitiesOut> {\r\n    return this.http.put<ApiSuccess<SupplyEntitiesOut>>(`${this.url}/supply-entities`, body)\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   * Sends a POST request to create a new employee record.\r\n   *\r\n   * @param {EmployeeIn} body - The data of the employee to be created.\r\n   * @return {Observable<EmployeeOut>} An observable containing the created employee data.\r\n   */\r\n  postEmployee (body: EmployeeIn): Observable<EmployeeOut> {\r\n    return this.http.post<ApiSuccess<EmployeeOut>>(`${this.url}/employees`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing employee record with the specified data.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee to be updated.\r\n   * @param {EmployeeIn} body - The employee data to update the record with.\r\n   * @return {Observable<EmployeeOut>} An observable containing the updated employee data.\r\n   */\r\n  putEmployee (id: number, body: EmployeeIn): Observable<EmployeeOut> {\r\n    return this.http.put<ApiSuccess<EmployeeOut>>(`${this.url}/employees/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes an employee based on the provided ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee to delete.\r\n   * @return {Observable<{}>} An observable containing the response data after the employee is deleted.\r\n   */\r\n  deleteEmployee (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${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   * Fetches the location employee details for a given employee ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee whose location details are to be retrieved.\r\n   * @return {Observable<LocationEmployeeOut>} An observable containing the location employee details.\r\n   */\r\n  getLocationEmployee (id: number): Observable<LocationEmployeeOut> {\r\n    return this.http.get<ApiSuccess<LocationEmployeeOut>>(`${this.url}/location-employees/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes a specific location employee by their unique identifier.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee to be deleted.\r\n   * @return {Observable<{}>} - An observable emitting the server's response after the deletion.\r\n   */\r\n  deleteLocationEmployee (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/location-employees/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a batch of location-employee associations to the server for processing.\r\n   *\r\n   * @param {LocationEmployeeBatchIn} body - The object containing a batch of location-employee data to be posted.\r\n   * @return {Observable<EmployeeOut>} An observable emitting the processed employee data from the server's response.\r\n   */\r\n  postLocationEmployeeBatch (body: LocationEmployeeBatchIn): Observable<EmployeeOut> {\r\n    return this.http.post<ApiSuccess<EmployeeOut>>(`${this.url}/location-employees/batch`, body)\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`, { 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   * Sends a request to update or create a company country entry on the server.\r\n   *\r\n   * @param {CompanyCountryIn} body The data object representing the company country information to be sent to the server.\r\n   * @return {Observable<CompanyCountryOut>} An observable containing the server response with the updated or created company country data.\r\n   */\r\n  postCompanyCountry (body: CompanyCountryIn): Observable<CompanyCountryOut> {\r\n    return this.http.post<ApiSuccess<CompanyCountryOut>>(`${this.url}/company-countries`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the country information for a specific company.\r\n   *\r\n   * @param {number} id - The unique identifier of the company whose country information needs to be updated.\r\n   * @param {CompanyCountryIn} body - The updated country information to be applied to the company.\r\n   * @return {Observable<CompanyCountryOut>} An observable that emits the updated company country information.\r\n   */\r\n  putCompanyCountry (id: number, body: CompanyCountryIn): Observable<CompanyCountryOut> {\r\n    return this.http.put<ApiSuccess<CompanyCountryOut>>(`${this.url}/company-countries/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes a company-country association by its unique identifier.\r\n   *\r\n   * @param {number} id - The unique identifier of the company-country record to be deleted.\r\n   * @return {Observable<{}>} An observable emitting the result of the delete operation.\r\n   */\r\n  deleteCompanyCountry (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${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>>(`${this.url}/country-reference-currencies`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the reference currency details for a specific country using its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country.\r\n   * @return {Observable<CountryReferenceCurrencyOut>} An observable emitting the country's reference currency details.\r\n   */\r\n  getCountryReferenceCurrency (id: number): Observable<CountryReferenceCurrencyOut> {\r\n    return this.http.get<ApiSuccess<CountryReferenceCurrencyOut>>(`${this.url}/country-reference-currencies/${id}`)\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   * Updates the reference currency for a specified country.\r\n   *\r\n   * @param {number} id - The unique identifier of the country.\r\n   * @param {CountryReferenceCurrencyIn} body - The data for updating the country's reference currency.\r\n   * @return {Observable<CountryReferenceCurrencyOut>} An Observable emitting the updated country reference currency data.\r\n   */\r\n  putCountryReferenceCurrency (id: number, body: CountryReferenceCurrencyIn): Observable<CountryReferenceCurrencyOut> {\r\n    return this.http.put<ApiSuccess<CountryReferenceCurrencyOut>>(`${this.url}/country-reference-currencies/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a country reference currency.\r\n   *\r\n   * @param {CountryReferenceCurrencyIn} body - The payload containing the country reference currency data.\r\n   * @return {Observable<CountryReferenceCurrencyOut>} An observable emitting the created country reference currency.\r\n   */\r\n  postCountryReferenceCurrency (body: CountryReferenceCurrencyIn): Observable<CountryReferenceCurrencyOut> {\r\n    return this.http.post<ApiSuccess<CountryReferenceCurrencyOut>>(`${this.url}/country-reference-currencies`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update a country reference extra charge.\r\n   *\r\n   * @param {CountryReferenceExtraChargeIn} body - The request payload containing details about the country reference extra charge.\r\n   * @return {Observable<CountryReferenceExtraChargeOut>} An observable containing the response with the created or updated country reference extra charge.\r\n   */\r\n  postCountryReferenceExtraCharge (body: CountryReferenceExtraChargeIn): Observable<CountryReferenceExtraChargeOut> {\r\n    return this.http.post<ApiSuccess<CountryReferenceExtraChargeOut>>(`${this.url}/country-reference-extra-charges`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates a country reference extra charge by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country reference extra charge to be updated.\r\n   * @param {CountryReferenceExtraChargeIn} body - The data to update the country reference extra charge with.\r\n   * @return {Observable<CountryReferenceExtraChargeOut>} An observable that emits the updated country reference extra charge.\r\n   */\r\n  putCountryReferenceExtraCharge (id: number, body: CountryReferenceExtraChargeIn): Observable<CountryReferenceExtraChargeOut> {\r\n    return this.http.put<ApiSuccess<CountryReferenceExtraChargeOut>>(`${this.url}/country-reference-extra-charges/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Enables or disables a country reference extra charge based on the provided parameters.\r\n   *\r\n   * @param {CountryReferenceExtraCharge} extraCharge - The country reference extra charge object to be updated.\r\n   * @param {boolean} [isActive] - Optional parameter to explicitly set the active status of the extra charge.\r\n   *                               If not provided, the current active status will be toggled.\r\n   * @return {Observable<EmployeeCustomersOut>} An Observable that emits the updated employee customers output.\r\n   */\r\n  patchCountryReferenceExtraCharge (extraCharge: CountryReferenceExtraCharge, isActive?: boolean): Observable<EmployeeCustomersOut> {\r\n    return this.http.patch<ApiSuccess<EmployeeCustomersOut>>(`${this.url}/country-reference-extra-charges/${extraCharge.id}`, {\r\n      is_active: isActive ?? !extraCharge.is_active\r\n    }).pipe(map(({ data }) => data))\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`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update an exchange.\r\n   *\r\n   * @param {ExchangeIn} body - The request body containing the exchange data to be sent.\r\n   * @return {Observable<ExchangeOut>} An observable that emits the response containing the created or updated exchange data.\r\n   */\r\n  postExchange (body: ExchangeIn): Observable<ExchangeOut> {\r\n    return this.http.post<ApiSuccess<ExchangeOut>>(`${this.url}/exchanges`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing exchange with new data.\r\n   *\r\n   * @param {number} id - The unique identifier of the exchange to update.\r\n   * @param {ExchangeIn} body - The data to update the exchange with.\r\n   * @return {Observable<ExchangeOut>} An observable that emits the updated exchange data.\r\n   */\r\n  putExchange (id: number, body: ExchangeIn): Observable<ExchangeOut> {\r\n    return this.http.put<ApiSuccess<ExchangeOut>>(`${this.url}/exchanges/${id}`, body)\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`, { 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`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches account information based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for fetching account data.\r\n   * @return {Observable<AccountsOut>} An observable emitting the account data.\r\n   */\r\n  getAccounts (params: QueryParams): Observable<AccountsOut> {\r\n    return this.http.get<ApiSuccess<AccountsOut>>(`${this.url}/accounts`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the account information for the specified account ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the account to retrieve.\r\n   * @return {Observable<AccountOut>} An observable that emits the account details.\r\n   */\r\n  getAccount (id: number): Observable<AccountOut> {\r\n    return this.http.get<ApiSuccess<AccountOut>>(`${this.url}/accounts/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new account by sending account details in the body.\r\n   *\r\n   * @param {AccountIn} body - The account information to be sent in the request body.\r\n   * @return {Observable<AccountOut>} Observable that emits the created account details upon success.\r\n   */\r\n  postAccount (body: AccountIn): Observable<AccountOut> {\r\n    return this.http.post<ApiSuccess<AccountOut>>(`${this.url}/accounts`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an account with the specified ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the account to be updated.\r\n   * @param {AccountIn} body - The data to update the account with.\r\n   * @return {Observable<AccountOut>} An observable emitting the updated account details.\r\n   */\r\n  putAccount (id: number, body: AccountIn): Observable<AccountOut> {\r\n    return this.http.put<ApiSuccess<AccountOut>>(`${this.url}/accounts/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches account entity data from the server based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to be sent with the HTTP request.\r\n   * @return {Observable<AccountEntitiesOut>} An observable that emits the account entities data.\r\n   */\r\n  getAccountEntities (params: QueryParams): Observable<AccountEntitiesOut> {\r\n    return this.http.get<ApiSuccess<AccountEntitiesOut>>(`${this.url}/account-entities`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an account entity using the provided details.\r\n   *\r\n   * @param {AccountEntitiesIn} body The account entity data to be updated.\r\n   * @return {Observable<AccountEntitiesOut>} An observable containing the updated account entity details.\r\n   */\r\n  putAccountEntity (body: AccountEntitiesIn): Observable<AccountEntitiesOut> {\r\n    return this.http.put<ApiSuccess<AccountEntitiesOut>>(`${this.url}/account-entities`, body)\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  getAccountEntitiesActives (params: QueryParams): Observable<AccountEntitiesOut> {\r\n    return this.http.get<ApiSuccess<AccountEntitiesOut>>(`${this.url}/account-entities/actives`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of account categories based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter the account categories.\r\n   * @return {Observable<AccountCategoriesOut>} An observable that emits the fetched account categories data.\r\n   */\r\n  getAccountCategories (params: QueryParams): Observable<AccountCategoriesOut> {\r\n    return this.http.get<ApiSuccess<AccountCategoriesOut>>(`${this.url}/account-categories`, { params, })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of account types from the server.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter or customize the request.\r\n   * @return {Observable<AccountTypesOut>} An observable emitting the account types data.\r\n   */\r\n  getAccountTypes (params: QueryParams): Observable<AccountTypesOut> {\r\n    return this.http.get<ApiSuccess<AccountTypesOut>>(`${this.url}/account-types`, { params, })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the account type for the given account ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the account.\r\n   * @return {Observable<AccountTypeOut>} An observable that emits the account type data.\r\n   */\r\n  getAccountType (id: number): Observable<AccountTypeOut> {\r\n    return this.http.get<ApiSuccess<AccountTypeOut>>(`${this.url}/account-types/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a new account type.\r\n   *\r\n   * @param {AccountTypeIn} body - The data for the account type to be created.\r\n   * @return {Observable<AccountTypeOut>} An observable that emits the created account type object.\r\n   */\r\n  postAccountType (body: AccountTypeIn): Observable<AccountTypeOut> {\r\n    return this.http.post<ApiSuccess<AccountTypeOut>>(`${this.url}/account-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an account type with the specified ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the account type to update.\r\n   * @param {AccountTypeIn} body - The data to update the account type with.\r\n   * @return {Observable<AccountTypeOut>} An observable containing the updated account type data.\r\n   */\r\n  putAccountType (id: number, body: AccountTypeIn): Observable<AccountTypeOut> {\r\n    return this.http.put<ApiSuccess<AccountTypeOut>>(`${this.url}/account-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves parameters based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter or fetch the desired parameters.\r\n   * @return {Observable<ParametersOut>} An observable that emits the fetched parameters.\r\n   */\r\n  getParameters (params: QueryParams): Observable<ParametersOut> {\r\n    return this.http.get<ApiSuccess<ParametersOut>>(`${this.url}/parameters`, { 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  postParametersValues ({ paramNames }: ParametersValuesIn): 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`, { parameters })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves parameter values based on the provided level configuration.\r\n   *\r\n   * @param {ParametersByLevelIn} parameters - The input object containing the criteria or level details to retrieve the parameters.\r\n   * @return {Observable<ParametersValuesOut>} An observable that emits the parameter values fetched from the server.\r\n   */\r\n  postParameterValueByModel (parameters: ParametersByLevelIn): Observable<ParametersValuesOut> {\r\n    return this.http.post<ApiSuccess<ParametersValuesOut>>(`${this.url}/parameters-values`, { 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`, { 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   * Updates a country reference resource with the specified ID and data.\r\n   *\r\n   * @param {number} id - The unique identifier of the country reference to be updated.\r\n   * @param {CountryReferenceIn} body - The data to update the country reference with.\r\n   * @return {Observable<CountryReferenceOut>} An observable that emits the updated country reference object.\r\n   */\r\n  putCountryReference (id: number, body: CountryReferenceIn): Observable<CountryReferenceOut> {\r\n    return this.http.put<ApiSuccess<CountryReferenceOut>>(`${this.url}/country-references/${id}`, body)\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`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of employee customer\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter employee customers.\r\n   * @return {Observable<EmployeeCustomersOut>} An observable containing the employee customer data.\r\n   */\r\n  getEmployeesCustomers (params: QueryParams): Observable<EmployeesCustomersOut> {\r\n    return this.http.get<ApiSuccess<EmployeesCustomersOut>>(`${this.url}/employee-customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update employee customer records and processes the server response.\r\n   *\r\n   * @param {EmployeeCustomersIn} body - The request payload containing employee customer data to be sent to the server.\r\n   * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee customer data on successful response.\r\n   */\r\n  postEmployeeCustomers (body: EmployeeCustomersIn): Observable<EmployeeCustomersOut> {\r\n    return this.http.post<ApiSuccess<EmployeeCustomersOut>>(`${this.url}/employee-customers`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the employee-customer association record identified by the given ID with the provided data.\r\n   *\r\n   * @param {number} id - The identifier of the employee-customer record to update.\r\n   * @param {EmployeeCustomersIn} body - The data to update the employee-customer record with.\r\n   * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee-customer data.\r\n   */\r\n  putEmployeeCustomers (id: number, body: EmployeeCustomersIn): Observable<EmployeeCustomersOut> {\r\n    return this.http.put<ApiSuccess<EmployeeCustomersOut>>(`${this.url}/employee-customers/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the employee-customer details based on the provided employee customer ID.\r\n   *\r\n   * @param {number} id - The identifier of the employee-customer record to update.\r\n   * @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee-customer data.\r\n   */\r\n  getEmployeeCustomer (id: number): Observable<EmployeeCustomersOut> {\r\n    return this.http.get<ApiSuccess<EmployeeCustomersOut>>(`${this.url}/employee-customers/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Enables or disables an employee customer's active state.\r\n   *\r\n   * @param {EmployeeCustomerDhl} employee - The employee customer object to be updated.\r\n   * @param {boolean} [isActive] - Optional parameter to explicitly set the active state.\r\n   *                                If null or undefined, the active state will be toggled.\r\n   * @return {Observable<EmployeeCustomersOut>} An observable containing the updated employee customer output.\r\n   */\r\n  patchEmployeeCustomers (employee: EmployeeCustomerDhl, isActive?: boolean): Observable<EmployeeCustomersOut> {\r\n    return this.http.patch<ApiSuccess<EmployeeCustomersOut>>(`${this.url}/employee-customers/${employee.id}`, {\r\n      is_active: isActive ?? !employee.is_active\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Submits a file containing employee customer data for a specific country to the server.\r\n   *\r\n   * @param {number} countryId - The identifier of the country for which the data is being uploaded.\r\n   * @param {File} file - The file contains employee customer data to be uploaded.\r\n   * @return {Observable<BoardingProcessIdIn>} Observable that emits the processed boarding process ID on success.\r\n   */\r\n  postEmployeeCustomersLoad (countryId: number, file: File): Observable<BoardingProcessIdIn> {\r\n    const body = new FormData()\r\n\r\n    body.append('file', file)\r\n    body.append('country_id', countryId.toString())\r\n\r\n    return this.http.post<ApiSuccess<BoardingProcessIdIn>>(`${this.url}/employee-customers/load`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Downloads a file containing customer data for a specific employee based on the provided country ID.\r\n   *\r\n   * @param {number} id - The ID of the country used as a filter for fetching the employee's customers.\r\n   * @return {Observable<Blob>} An observable that emits the file blob containing the customer data.\r\n   */\r\n  getEmployeeCustomersDownload (id:number):Observable<Blob> {\r\n    return this.http.get(`${this.url}/employee-customers/download`, {\r\n      params: { country_id: id },\r\n      responseType: 'blob'\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Retrieves the boarding process details for a given ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the boarding process to retrieve.\r\n   * @return {Observable<BoardingProcessIn>} An observable containing the boarding process details.\r\n   */\r\n  getBoardingProcess (id:number) {\r\n    return this.http.get<ApiSuccess<BoardingProcessIn>>(`${this.url}/boarding-process/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of systems based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter the systems.\r\n   * @return {Observable<SystemsOut>} An observable that emits the retrieved systems data.\r\n   */\r\n  getSystems (params: QueryParams): Observable<SystemsOut> {\r\n    return this.http.get<ApiSuccess<SystemsOut>>(`${this.url}/systems`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the system by the specified ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the system to be retrieved.\r\n   * @return {Observable<SystemOut>} An observable that emits the requested system information.\r\n   */\r\n  getSystem (id: number): Observable<SystemOut> {\r\n    return this.http.get<ApiSuccess<SystemOut>>(`${this.url}/systems/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update a system.\r\n   *\r\n   * @param {SystemIn} body - The data representing the system to be created or updated.\r\n   * @return {Observable<SystemOut>} An observable emitting the resulting system output after the API request succeeds.\r\n   */\r\n  postSystem (body: SystemIn): Observable<SystemOut> {\r\n    return this.http.post<ApiSuccess<SystemOut>>(`${this.url}/systems`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the system identified by the given ID with the provided request body and returns the updated system details.\r\n   *\r\n   * @param {number} id - The unique identifier of the system to be updated.\r\n   * @param {SystemIn} body - The payload containing the updated system details.\r\n   * @return {Observable<SystemOut>} An observable emitting the updated system data.\r\n   */\r\n  putSystem (id: number, body: SystemIn): Observable<SystemOut> {\r\n    return this.http.put<ApiSuccess<SystemOut>>(`${this.url}/systems/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of system entities based on the specified query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter or specify the system entities to retrieve.\r\n   * @return {Observable<SystemEntitiesOut>} An Observable that emits the retrieved system entities.\r\n   */\r\n  getSystemEntities (params: QueryParams): Observable<SystemEntitiesOut> {\r\n    return this.http.get<ApiSuccess<SystemEntitiesOut>>(`${this.url}/system-entities`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the system entities by sending the provided data to the server.\r\n   *\r\n   * @param {SystemEntitiesIn} body - The data object representing the system entities to be updated.\r\n   * @return {Observable<SystemEntitiesOut>} An observable containing the updated system entities data.\r\n   */\r\n  putSystemEntities (body: SystemEntitiesIn): Observable<SystemEntitiesOut> {\r\n    return this.http.put<ApiSuccess<SystemEntitiesOut>>(`${this.url}/system-entities`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves workflow configurations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the workflow configurations.\r\n   * @return {Observable<WorkflowConfigsOut>} An observable emitting the workflow configurations.\r\n   */\r\n  getWorkflowConfigs (params: QueryParams): Observable<WorkflowConfigsOut> {\r\n    return this.http.get<ApiSuccess<WorkflowConfigsOut>>(`${this.url}/workflow-configs`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a batch of workflow configuration data to the server for processing.\r\n   *\r\n   * @param {WorkflowConfigsBatchIn} body - The input data containing a batch of workflow configurations to be sent.\r\n   * @return {Observable<WorkflowConfigsOut>} An observable that emits the processed batch of workflow configuration data as a response.\r\n   */\r\n  postWorkflowConfigsBatch (body: WorkflowConfigsBatchIn): Observable<WorkflowConfigsOut> {\r\n    return this.http.post<ApiSuccess<WorkflowConfigsOut>>(`${this.url}/workflow-configs/batch`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create a new company and returns the created company's details.\r\n   *\r\n   * @param {CompanyIn} body - The payload containing the details of the company to be created.\r\n   * @return {Observable<CompanyOut>} An Observable emitting the response with the created company's details.\r\n   */\r\n  postCompany (body: CompanyIn): Observable<CompanyOut> {\r\n    return this.http.post<ApiSuccess<CompanyOut>>(`${this.url}/companies`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the details of an existing company using its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the company to update.\r\n   * @param {CompanyIn} body - The object containing the updated company data.\r\n   * @return {Observable<CompanyOut>} An observable that emits the updated company details.\r\n   */\r\n  putCompany (id: number, body: CompanyIn): Observable<CompanyOut> {\r\n    return this.http.put<ApiSuccess<CompanyOut>>(`${this.url}/companies/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes a company by its unique identifier.\r\n   *\r\n   * @param {number} id - The unique identifier of the company to be deleted.\r\n   * @return {Observable<{}>} An observable that emits an empty object upon successful deletion or an error if the operation fails.\r\n   */\r\n  deleteCompany (id: number): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/companies/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches product entities from the server based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params The query parameters used to modify the request for product entities.\r\n   * @return {Observable<ProductEntitiesOut>} An observable that emits the product entities retrieved from the server.\r\n   */\r\n  getProductEntities (params: QueryParams): Observable<ProductEntitiesOut> {\r\n    return this.http.get<ApiSuccess<ProductEntitiesOut>>(`${this.url}/product-entities`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a PUT request to update product entities and returns the updated entity.\r\n   *\r\n   * @param {ProductEntitiesIn} body - The payload containing the data to update the product entity.\r\n   * @return {Observable<ProductEntitiesOut>} Observable that emits the updated product entity.\r\n   */\r\n  putProductEntities (body: ProductEntitiesIn): Observable<ProductEntitiesOut> {\r\n    return this.http.put<ApiSuccess<ProductEntitiesOut>>(`${this.url}/product-entities`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the country reference products based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params The query parameters used to filter and retrieve the country reference products.\r\n   * @return {Observable<CountryReferenceProductsOut>} An observable emitting the fetched country reference products data.\r\n   */\r\n  getCountryReferenceProducts (params: QueryParams): Observable<CountryReferenceProductsOut> {\r\n    return this.http.get<ApiSuccess<CountryReferenceProductsOut>>(`${this.url}/country-reference-products`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a request to update or create country reference products.\r\n   *\r\n   * @param {CountryReferenceProductIn} body - The payload containing the details of the country reference products to post.\r\n   * @return {Observable<CountryReferenceProductOut>} An observable that emits the updated or created country reference product data.\r\n   */\r\n  postCountryReferenceProducts (body: CountryReferenceProductIn): Observable<CountryReferenceProductOut> {\r\n    return this.http.post<ApiSuccess<CountryReferenceProductOut>>(`${this.url}/country-reference-products`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates a country reference product with the specified ID using the provided data.\r\n   *\r\n   * @param {number} id - The unique identifier of the country reference product to update.\r\n   * @param {CountryReferenceProductIn} body - The updated country reference product data to be sent in the request body.\r\n   * @return {Observable<CountryReferenceProductOut>} An observable emitting the updated country reference product.\r\n   */\r\n  putCountryReferenceProducts (id: number, body: CountryReferenceProductIn): Observable<CountryReferenceProductOut> {\r\n    return this.http.put<ApiSuccess<CountryReferenceProductOut>>(`${this.url}/country-reference-products/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the extra charge entities from the server based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - An object containing the query parameters to filter the extra charge entities.\r\n   * @return {Observable<ExtraChargeEntitiesOut>} An observable that emits the extra charge entities retrieved from the server.\r\n   */\r\n  getExtraChargeEntities (params: QueryParams): Observable<ExtraChargeEntitiesOut> {\r\n    return this.http.get<ApiSuccess<ExtraChargeEntitiesOut>>(`${this.url}/extracharge-entities`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates extra charge entities by sending the provided data to the server.\r\n   *\r\n   * @param {ExtraChargeEntitiesIn} body - The data to update the extra charge entities.\r\n   * @return {Observable<ExtraChargeEntitiesOut>} An observable that emits the updated extra charge entities.\r\n   */\r\n  putExtraChargeEntities (body: ExtraChargeEntitiesIn): Observable<ExtraChargeEntitiesOut> {\r\n    return this.http.put<ApiSuccess<ExtraChargeEntitiesOut>>(`${this.url}/extracharge-entities`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the parameter configurations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the parameter configurations.\r\n   * @return {Observable<ParameterConfigsOut>} An observable that emits the parameter configurations data.\r\n   */\r\n  getParameterConfigs (params: QueryParams): Observable<ParameterConfigsOut> {\r\n    return this.http.get<ApiSuccess<ParameterConfigsOut>>(`${this.url}/parameter-configs`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update a parameter configuration.\r\n   *\r\n   * @param {ParameterConfigIn} body - The input data object containing the parameter configuration to be sent in the request body.\r\n   * @return {Observable<ParameterConfigOut>} An observable that emits the server's response containing the updated or newly created parameter configuration.\r\n   */\r\n  postParameterConfig (body: ParameterConfigIn): Observable<ParameterConfigOut> {\r\n    return this.http.post<ApiSuccess<ParameterConfigOut>>(`${this.url}/parameter-configs`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates the configuration of a parameter with the provided ID and input data.\r\n   *\r\n   * @param {number} id - The unique identifier of the parameter configuration to be updated.\r\n   * @param {ParameterConfigIn} body - The input data containing the updated configuration for the parameter.\r\n   * @return {Observable<ParameterConfigOut>} An observable that emits the updated parameter configuration.\r\n   */\r\n  putParameterConfig (id: number, body: ParameterConfigIn): Observable<ParameterConfigOut> {\r\n    return this.http.put<ApiSuccess<ParameterConfigOut>>(`${this.url}/parameter-configs/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes a parameter configuration specified by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the parameter configuration to be deleted.\r\n   * @return {Observable<ParameterConfigOut>} An observable containing the deleted parameter configuration data.\r\n   */\r\n  deleteParameterConfig (id: number): Observable<ParameterConfigOut> {\r\n    return this.http.delete<ApiSuccess<ParameterConfigOut>>(`${this.url}/parameter-configs/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of TDX account settings based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters used to filter or paginate the results.\r\n   * @returns {Observable<TDXAccountsSettingsOut>} An observable containing the list of TDX account settings.\r\n   */\r\n  getTDXAccountsSettings (params: QueryParams): Observable<TDXAccountsSettingsOut> {\r\n    return this.http.get<ApiSuccess<TDXAccountsSettingsOut>>(`${this.url}/tdx-account-settings`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a single TDX account setting by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the TDX account setting to be retrieved.\r\n   * @returns {Observable<TDXAccountSettingsOut>} An observable containing the requested TDX account setting.\r\n   */\r\n  getTDXAccountSettings (id: number): Observable<TDXAccountSettingsOut> {\r\n    return this.http.get<ApiSuccess<TDXAccountSettingsOut>>(`${this.url}/tdx-account-settings/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new TDX account setting with the provided data.\r\n   *\r\n   * @param {TDXAccountSettingsIn} body - The data used to create the new TDX account setting.\r\n   * @returns {Observable<TDXAccountSettingsOut>} An observable containing the newly created TDX account setting.\r\n   */\r\n  postTDXAccountSettings (body:TDXAccountSettingsIn): Observable<TDXAccountSettingsOut> {\r\n    return this.http.post<ApiSuccess<TDXAccountSettingsOut>>(`${this.url}/tdx-account-settings`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing TDX account setting identified by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the TDX account setting to be updated.\r\n   * @param {TDXAccountSettingsIn} body - The updated data for the TDX account setting.\r\n   * @returns {Observable<TDXAccountSettingsOut>} An observable containing the updated TDX account setting.\r\n   */\r\n  putTDXAccountSettings (id: number, body:TDXAccountSettingsIn): Observable<TDXAccountSettingsOut> {\r\n    return this.http.put<ApiSuccess<TDXAccountSettingsOut>>(`${this.url}/tdx-account-settings/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the employees of a specific location using a provided token.\r\n   *\r\n   * @param params - Input parameters for the request, defined by the `LocationEmployeesIn` interface.\r\n   * @returns An `Observable<LocationEmployeesOut>` that emits the employees\r\n   * associated with the given location.\r\n   * @returns The response type is `ApiSuccess<LocationEmployeesOut>`, from which the `data` field is extracted.\r\n   */\r\n  getLocationEmployeesByToken (params: { token: string, queryParams: QueryParams }): Observable<LocationEmployeesOut> {\r\n    return this.http.get<ApiSuccess<LocationEmployeesOut>>(`${this.url}/location-employees`, {\r\n      params: params.queryParams,\r\n      headers: {\r\n        Authorization: `Bearer ${params.token}`\r\n      }\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}