@experteam-mx/ngx-services 0.1.1 → 15.1.0

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

@@ -0,0 +1,255 @@
+import { Inject, Injectable } from '@angular/core';
+import { forkJoin, map, mergeMap } from 'rxjs';
+import { httpParams } from '../helpers/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiCompaniesService {
+    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<InstallationsData>} An observable that emits the installations data.
+     */
+    getInstallations(params) {
+        return this.http.get(`${this.url}/installations`, {
+            params: httpParams(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<InstallationData>} An observable of the installation details.
+     */
+    getInstallation(id) {
+        return this.http.get(`${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<LocationsData>} An observable that emits the locations data.
+     */
+    getLocations(params) {
+        return this.http.get(`${this.url}/locations`, {
+            params: httpParams(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<LocationData>} An Observable containing the location details.
+     */
+    getLocation(id) {
+        return this.http.get(`${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<SupplyEntitiesData>} Observable emitting supply entities data.
+     */
+    getSupplyEntitiesActive(params) {
+        return this.http.get(`${this.url}/supply-entities/actives`, {
+            params: httpParams(params),
+        }).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<EmployeesData>} An observable that emits the list of employees.
+     */
+    getEmployees(params) {
+        return this.http.get(`${this.url}/employees`, {
+            params: httpParams(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<EmployeeData>} An observable that emits the employee's details.
+     */
+    getEmployee(id) {
+        return this.http.get(`${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<LocationEmployeesData>} An observable that emits the list of employees for the specified location.
+     */
+    getLocationEmployees(params) {
+        return this.http.get(`${this.url}/location-employees`, {
+            params: httpParams(params),
+        }).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<CompanyCountriesData>} An observable containing the list of company countries.
+     */
+    getCompanyCountries(params) {
+        return this.http.get(`${this.url}/company-countries`, {
+            params: httpParams(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<CompanyCountryData>} An observable containing the country information of the company.
+     */
+    getCompanyCountry(id) {
+        return this.http.get(`${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<CountryReferenceCurrenciesData>} 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 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((country_reference_currency) => this.getCurrentExchanges({
+                currency_id: country_reference_currency.currency.id,
+            }).pipe(map((exchangesData) => ({
+                ...country_reference_currency,
+                rate: exchangesData.exchanges[0]?.value ?? 1.00,
+            }))));
+            return forkJoin($observables);
+        }));
+    }
+    /**
+     * Retrieves the current exchanges based on the given query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the exchanges.
+     *
+     * @returns {Observable<ExchangesData>} - An observable that emits the API response data containing the current exchanges.
+     */
+    getCurrentExchanges(params) {
+        return this.http.get(`${this.url}/exchanges/current`, {
+            params: httpParams(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<CompanyCountryTaxesData>} An observable that emits the tax information.
+     */
+    getCompanyCountryTaxes(params) {
+        return this.http.get(`${this.url}/company-country-taxes`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the list of active account entities based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters to filter and query active account entities.
+     * @return {Observable<AccountEntitiesData>} An observable that emits the list of active account entities.
+     */
+    getActiveAccountEntities(params) {
+        return this.http.get(`${this.url}/account-entities/actives`, {
+            params: httpParams(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<ParametersData>} An observable that emits the fetched parameter values.
+     */
+    getParameters({ paramNames, }) {
+        const parameters = paramNames.map((p) => ({ name: p }));
+        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<ParameterValueData>} 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<CountryReferencesData>} An observable containing the country reference data.
+     */
+    getCountryReferences(params) {
+        return this.http.get(`${this.url}/country-references`, {
+            params: httpParams(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<CountryReferenceData>} An observable containing the country reference data.
+     */
+    getCountryReference(id) {
+        return this.http.get(`${this.url}/country-references/${id}`)
+            .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<WorkflowsData>} An observable containing the workflow data.
+     */
+    getWorkflows(params) {
+        return this.http.get(`${this.url}/workflows`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+}
+ApiCompaniesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiCompaniesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+ApiCompaniesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiCompaniesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiCompaniesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ 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/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  AccountEntitiesData,\r\n  CompanyCountriesData,\r\n  CompanyCountryData,\r\n  CompanyCountryTaxesData,\r\n  CountryReferenceCurrenciesData,\r\n  CountryReferenceData,\r\n  CountryReferencesData,\r\n  EmployeeData,\r\n  EmployeesData,\r\n  ExchangesData,\r\n  InstallationData,\r\n  InstallationsData,\r\n  LocationData,\r\n  LocationEmployeesData,\r\n  LocationsData,\r\n  ParametersData,\r\n  ParametersProps,\r\n  ParameterValueData,\r\n  ParameterValueProps,\r\n  SupplyEntitiesData,\r\n  WorkflowsData\r\n} from './models/api-companies.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport { forkJoin, map, mergeMap, Observable } from 'rxjs'\r\nimport { httpParams } from '../helpers/http'\r\nimport { CountryCurrencyRate } from './models/api-companies.interfaces'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCompaniesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient,\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the URL for the companies API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the companies API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCompaniesUrl\r\n  }\r\n\r\n  /**\r\n   * Fetches the installations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter the installations query.\r\n   * @return {Observable<InstallationsData>} An observable that emits the installations data.\r\n   */\r\n  getInstallations (params: QueryParams): Observable<InstallationsData> {\r\n    return this.http.get<ApiSuccess<InstallationsData>>(`${this.url}/installations`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the installation details based on the given installation ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the installation to retrieve.\r\n   * @returns {Observable<InstallationData>} An observable of the installation details.\r\n   */\r\n  getInstallation (id: number): Observable<InstallationData> {\r\n    return this.http.get<ApiSuccess<InstallationData>>(`${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<LocationsData>} An observable that emits the locations data.\r\n   */\r\n  getLocations (params: QueryParams): Observable<LocationsData> {\r\n    return this.http.get<ApiSuccess<LocationsData>>(`${this.url}/locations`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the location details for a given location ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the location.\r\n   * @return {Observable<LocationData>} An Observable containing the location details.\r\n   */\r\n  getLocation (id: number): Observable<LocationData> {\r\n    return this.http.get<ApiSuccess<LocationData>>(`${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<SupplyEntitiesData>} Observable emitting supply entities data.\r\n   */\r\n  getSupplyEntitiesActive (params: QueryParams): Observable<SupplyEntitiesData> {\r\n    return this.http.get<ApiSuccess<SupplyEntitiesData>>(`${this.url}/supply-entities/actives`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of employees based on the specified query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and sort the employees.\r\n   * @return {Observable<EmployeesData>} An observable that emits the list of employees.\r\n   */\r\n  getEmployees (params: QueryParams): Observable<EmployeesData> {\r\n    return this.http.get<ApiSuccess<EmployeesData>>(`${this.url}/employees`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches an employee's details based on the provided employee ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee.\r\n   * @return {Observable<EmployeeData>} An observable that emits the employee's details.\r\n   */\r\n  getEmployee (id: number): Observable<EmployeeData> {\r\n    return this.http.get<ApiSuccess<EmployeeData>>(`${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<LocationEmployeesData>} An observable that emits the list of employees for the specified location.\r\n   */\r\n  getLocationEmployees (params: QueryParams): Observable<LocationEmployeesData> {\r\n    return this.http.get<ApiSuccess<LocationEmployeesData>>(`${this.url}/location-employees`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of countries where the company operates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for the API request.\r\n   * @return {Observable<CompanyCountriesData>} An observable containing the list of company countries.\r\n   */\r\n  getCompanyCountries (params: QueryParams): Observable<CompanyCountriesData> {\r\n    return this.http.get<ApiSuccess<CompanyCountriesData>>(`${this.url}/company-countries`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\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<CompanyCountryData>} An observable containing the country information of the company.\r\n   */\r\n  getCompanyCountry (id: number): Observable<CompanyCountryData> {\r\n    return this.http.get<ApiSuccess<CompanyCountryData>>(`${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<CountryReferenceCurrenciesData>} The observable containing the country reference currencies data.\r\n   */\r\n  getCountryReferenceCurrencies (params: QueryParams): Observable<CountryReferenceCurrenciesData> {\r\n    return this.http.get<ApiSuccess<CountryReferenceCurrenciesData>>(\r\n      `${this.url}/country-reference-currencies`,\r\n      { params }\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of currencies for different countries along with their current exchange rates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.\r\n   * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.\r\n   */\r\n  getCountryCurrenciesWithRate (params: QueryParams): Observable<CountryCurrencyRate[]> {\r\n    return this.getCountryReferenceCurrencies(params)\r\n      .pipe(mergeMap((currenciesData) => {\r\n        const $observables = currenciesData.country_reference_currencies\r\n          .map((country_reference_currency) =>\r\n            this.getCurrentExchanges({\r\n              currency_id: country_reference_currency.currency.id,\r\n            }).pipe(\r\n              map((exchangesData) => ({\r\n                ...country_reference_currency,\r\n                rate: exchangesData.exchanges[0]?.value ?? 1.00,\r\n              }))\r\n            )\r\n          )\r\n\r\n        return forkJoin($observables)\r\n      }))\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<ExchangesData>} - An observable that emits the API response data containing the current exchanges.\r\n   */\r\n  getCurrentExchanges (params: QueryParams): Observable<ExchangesData> {\r\n    return this.http.get<ApiSuccess<ExchangesData>>(`${this.url}/exchanges/current`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country-specific tax information for a company.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter and query the taxes.\r\n   * @return {Observable<CompanyCountryTaxesData>} An observable that emits the tax information.\r\n   */\r\n  getCompanyCountryTaxes (params: QueryParams): Observable<CompanyCountryTaxesData> {\r\n    return this.http.get<ApiSuccess<CompanyCountryTaxesData>>(`${this.url}/company-country-taxes`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of active account entities based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and query active account entities.\r\n   * @return {Observable<AccountEntitiesData>} An observable that emits the list of active account entities.\r\n   */\r\n  getActiveAccountEntities (params: QueryParams): Observable<AccountEntitiesData> {\r\n    return this.http.get<ApiSuccess<AccountEntitiesData>>(`${this.url}/account-entities/actives`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the parameter values based on the provided parameter names.\r\n   *\r\n   * @param {Object} params - An object containing the required parameters.\r\n   * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.\r\n   * @return {Observable<ParametersData>} An observable that emits the fetched parameter values.\r\n   */\r\n  getParameters ({\r\n    paramNames,\r\n  }: ParametersProps): Observable<ParametersData> {\r\n    const parameters = paramNames.map((p) => ({ name: p }))\r\n\r\n    return this.http.post<ApiSuccess<ParametersData>>(`${this.url}/parameters-values`, {\r\n      parameters\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the value of a specified parameter.\r\n   *\r\n   * @param {Object} input - The input object containing the parameter details.\r\n   * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.\r\n   * @return {Observable<ParameterValueData>} An observable emitting the value of the specified parameter.\r\n   */\r\n  getParameterValue ({\r\n    paramName,\r\n  }: ParameterValueProps): Observable<ParameterValueData> {\r\n    return this.http.get<ApiSuccess<ParameterValueData>>(`${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<CountryReferencesData>} An observable containing the country reference data.\r\n   */\r\n  getCountryReferences (params: QueryParams): Observable<CountryReferencesData> {\r\n    return this.http.get<ApiSuccess<CountryReferencesData>>(`${this.url}/country-references`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country reference data for a given country ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.\r\n   * @return {Observable<CountryReferenceData>} An observable containing the country reference data.\r\n   */\r\n  getCountryReference (id: number): Observable<CountryReferenceData> {\r\n    return this.http.get<ApiSuccess<CountryReferenceData>>(`${this.url}/country-references/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of workflows based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter workflows.\r\n   * @return {Observable<WorkflowsData>} An observable containing the workflow data.\r\n   */\r\n  getWorkflows (params: QueryParams): Observable<WorkflowsData> {\r\n    return this.http.get<ApiSuccess<WorkflowsData>>(`${this.url}/workflows`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

package/esm2020/lib/apis/api-security.service.mjs

@@ -2,64 +2,65 @@ import { Inject, Injectable } from '@angular/core';
 import { HttpHeaders } from '@angular/common/http';
 import { map, tap } from 'rxjs';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
-import * as i2 from "ngx-cookie-service";
+import * as i1 from "ngx-cookie-service";
+import * as i2 from "@angular/common/http";
 export class ApiSecurityService {
-    constructor(environments, httpClient, cookie) {
+    constructor(environments, cookie, http) {
         this.environments = environments;
-        this.httpClient = httpClient;
         this.cookie = cookie;
+        this.http = http;
     }
     /**
-     * Retrieves the API security URL.
+     * Retrieves the API security URL from the environments configuration.
      *
-     * @returns {string} The API security URL.
+     * @return {string} The API security URL.
      */
     get url() {
         return this.environments.apiSecurityUrl;
     }
     /**
-     * Logs in the user using the provided login credentials.
+     * Authenticates a user with the provided credentials and role.
      *
-     * @param {object} loginParams - The login parameters.
-     * @param {string} loginParams.username - The username of the user.
-     * @param {string} loginParams.password - The password of the user.
-     * @param {string} loginParams.role - The role of the user.
-     *
-     * @returns {Observable<LoginOut>} - An observable that emits the logged-in user's information.
+     * @param {Object} param0 - The login input object.
+     * @param {string} param0.username - The username of the user.
+     * @param {string} param0.password - The password of the user.
+     * @param {string} param0.role - The role of the user.
+     * @return {Observable<LoginOut>} An observable emitting the login output object.
      */
     login({ username, password, role, }) {
-        return this.httpClient.post(`${this.url}/auth/login`, {
+        return this.http.post(`${this.url}/auth/login`, {
             system_name: 'CRA',
             username,
             password,
             role,
-        }).pipe(map(({ data }) => data), tap(({ access_token }) => this.cookie.set('tokenCRA', access_token, { path: '/' })));
+        }).pipe(map(({ data }) => data), tap(({ access_token }) => this.cookie.set(this.environments.tokenName, access_token, { path: '/' })));
     }
     /**
-     * Logs out the user from the application.
+     * Logs out the current user by making a POST request to the logout endpoint.
+     *
+     * This method deletes all cookies after a successful logout.
      *
-     * @return {Observable<{}>} An observable that emits an empty object upon successful logout.
+     * @return {Observable<{}>} An observable that emits the server's response to the logout request.
      */
     logout() {
-        return this.httpClient.post(`${this.url}/auth/logout`, null)
+        return this.http.post(`${this.url}/auth/logout`, null)
             .pipe(map(({ data }) => data), tap(() => this.cookie.deleteAll('/')));
     }
     /**
-     * Creates a session with the given parameters.
+     * Creates a new session for a specified model.
      *
-     * @param {CreateSessionIn} options - The input parameters for session creation.
-     * @param {string} options.modelType - The session model type.
-     * @param {string} options.modelId - The session model ID.
-     * @param {string} options.token - The authorization token. Optional.
+     * @param {Object} params - The parameters for creating the session.
+     * @param {string} params.modelType - The type of the model.
+     * @param {string} params.modelId - The ID of the model.
+     * @param {string} [params.token] - Optional authorization token.
      *
-     * @return {Observable<CreateSessionOut>} - An Observable that emits the result of the session creation.
+     * @return {Observable<CreateSessionOut>} An observable containing the created session details.
      */
     createSession({ modelType, modelId, token, }) {
         let headers = new HttpHeaders({});
         if (token)
             headers = headers.set('Authorization', `Bearer ${token}`);
-        return this.httpClient.post(`${this.url}/sessions`, {
+        return this.http.post(`${this.url}/sessions`, {
             model_type: modelType,
             model_id: modelId,
         }, {
@@ -67,54 +68,53 @@ export class ApiSecurityService {
         }).pipe(map(({ data }) => data));
     }
     /**
-     * Retrieves user information.
+     * Fetches the authenticated user's information.
+     * Sends a GET request to the endpoint '/auth/me' to retrieve information
+     * about the currently authenticated user.
      *
-     * @returns {Observable<MeOut>} Observable of user information.
+     * @return {Observable<MeOut>} An observable that emits the authenticated user's data.
      */
     me() {
-        return this.httpClient.get(`${this.url}/auth/me`)
+        return this.http.get(`${this.url}/auth/me`)
             .pipe(map(({ data }) => data));
     }
     /**
-     * Retrieves user information from the API.
+     * Fetches the authenticated user's details from the server.
      *
-     * @param {GetUserIn} user - The user object containing the user ID.
-     *
-     * @returns {Observable<GetUserOut>} - An observable that emits the retrieved user data.
+     * @param token The JWT token used for authorization.
+     * @return An Observable that emits the user's details encapsulated in a MeOut object.
      */
-    user({ userId }) {
-        return this.httpClient.get(`${this.url}/users/${userId}`)
-            .pipe(map(({ data }) => data));
-    }
-    /**
-     * Get user information
-     *
-     * @param {string} token - The user's authentication token
-     *
-     * @return {Observable<MeOut>} - An observable that emits the user's information
-     */
-    userInfo({ token }) {
-        return this.httpClient.get(`${this.url}/auth/me`, {
+    otherMe(token) {
+        return this.http.get(`${this.url}/auth/me`, {
             headers: {
                 Authorization: `Bearer ${token}`
             }
         }).pipe(map(({ data }) => data));
     }
     /**
-     * Changes the language of the authenticated user.
+     * Fetches a user by their unique ID.
      *
-     * @param {Object} params - The parameters for changing the language.
-     * @param {string} params.languageId - The ID of the language to change to.
+     * @param {number} id - The unique identifier of the user to be fetched.
+     * @return {Observable<GetUserOut>} An observable containing the user information.
+     */
+    user(id) {
+        return this.http.get(`${this.url}/users/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Changes the language for the authenticated user.
      *
-     * @returns {Observable<Object>} - An observable that emits the updated user data.
+     * @param {Object} params - The input parameters for changing the language.
+     * @param {string} params.languageId - The ID of the new language to be set.
+     * @return {Observable<ApiSuccess<MeOut>>} An observable that emits the result of the language change request.
      */
     changeLanguage({ languageId }) {
-        return this.httpClient.put(`${this.url}/auth/me`, {
+        return this.http.put(`${this.url}/auth/me`, {
             language_id: languageId
         }).pipe(map(({ data }) => data));
     }
 }
-ApiSecurityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiSecurityService, deps: [{ token: 'env' }, { token: i1.HttpClient }, { token: i2.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+ApiSecurityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiSecurityService, deps: [{ token: 'env' }, { token: i1.CookieService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
 ApiSecurityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiSecurityService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiSecurityService, decorators: [{
             type: Injectable,
@@ -124,5 +124,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['env']
-                }] }, { type: i1.HttpClient }, { type: i2.CookieService }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-security.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam/ngx-services/src/lib/apis/api-security.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { ApiSuccess } from './api.models'\r\nimport {\r\n  ChangeLanguageIn,\r\n  CreateSessionIn,\r\n  CreateSessionOut,\r\n  GetUserIn,\r\n  GetUserInfoIn,\r\n  GetUserOut,\r\n  LoginIn,\r\n  LoginOut,\r\n  MeOut\r\n} from './api-security.models'\r\nimport { HttpClient, HttpHeaders } from '@angular/common/http'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { map, Observable, tap } from 'rxjs'\r\nimport { CookieService } from 'ngx-cookie-service'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiSecurityService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private httpClient: HttpClient,\r\n    private cookie: CookieService,\r\n  ) {}\r\n\r\n  /**\r\n   * Retrieves the API security URL.\r\n   *\r\n   * @returns {string} The API security URL.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiSecurityUrl\r\n  }\r\n\r\n  /**\r\n   * Logs in the user using the provided login credentials.\r\n   *\r\n   * @param {object} loginParams - The login parameters.\r\n   * @param {string} loginParams.username - The username of the user.\r\n   * @param {string} loginParams.password - The password of the user.\r\n   * @param {string} loginParams.role - The role of the user.\r\n   *\r\n   * @returns {Observable<LoginOut>} - An observable that emits the logged-in user's information.\r\n   */\r\n  login ({\r\n    username,\r\n    password,\r\n    role,\r\n  }: LoginIn): Observable<LoginOut> {\r\n    return this.httpClient.post<ApiSuccess<LoginOut>>(`${this.url}/auth/login`, {\r\n      system_name: 'CRA',\r\n      username,\r\n      password,\r\n      role,\r\n    }).pipe(\r\n      map(({ data }) => data),\r\n      tap(({ access_token }) => this.cookie.set('tokenCRA', access_token, { path: '/' }))\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Logs out the user from the application.\r\n   *\r\n   * @return {Observable<{}>} An observable that emits an empty object upon successful logout.\r\n   */\r\n  logout (): Observable<{}> {\r\n    return this.httpClient.post<ApiSuccess<{}>>(`${this.url}/auth/logout`, null)\r\n      .pipe(\r\n        map(({ data }) => data),\r\n        tap(() => this.cookie.deleteAll('/'))\r\n      )\r\n  }\r\n\r\n  /**\r\n   * Creates a session with the given parameters.\r\n   *\r\n   * @param {CreateSessionIn} options - The input parameters for session creation.\r\n   * @param {string} options.modelType - The session model type.\r\n   * @param {string} options.modelId - The session model ID.\r\n   * @param {string} options.token - The authorization token. Optional.\r\n   *\r\n   * @return {Observable<CreateSessionOut>} - An Observable that emits the result of the session creation.\r\n   */\r\n  createSession ({\r\n    modelType,\r\n    modelId,\r\n    token,\r\n  }: CreateSessionIn): Observable<CreateSessionOut> {\r\n    let headers = new HttpHeaders({})\r\n\r\n    if (token)\r\n      headers = headers.set('Authorization', `Bearer ${token}`)\r\n\r\n    return this.httpClient.post<ApiSuccess<CreateSessionOut>>(\r\n      `${this.url}/sessions`, {\r\n        model_type: modelType,\r\n        model_id: modelId,\r\n      }, {\r\n        headers\r\n      }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves user information.\r\n   *\r\n   * @returns {Observable<MeOut>} Observable of user information.\r\n   */\r\n  me (): Observable<MeOut> {\r\n    return this.httpClient.get<ApiSuccess<MeOut>>(`${this.url}/auth/me`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves user information from the API.\r\n   *\r\n   * @param {GetUserIn} user - The user object containing the user ID.\r\n   *\r\n   * @returns {Observable<GetUserOut>} - An observable that emits the retrieved user data.\r\n   */\r\n  user ({\r\n    userId\r\n  }: GetUserIn): Observable<GetUserOut> {\r\n    return this.httpClient.get<ApiSuccess<GetUserOut>>(`${this.url}/users/${userId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Get user information\r\n   *\r\n   * @param {string} token - The user's authentication token\r\n   *\r\n   * @return {Observable<MeOut>} - An observable that emits the user's information\r\n   */\r\n  userInfo ({\r\n    token\r\n  }: GetUserInfoIn): Observable<MeOut> {\r\n    return this.httpClient.get<ApiSuccess<MeOut>>(`${this.url}/auth/me`, {\r\n      headers: {\r\n        Authorization: `Bearer ${token}`\r\n      }\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Changes the language of the authenticated user.\r\n   *\r\n   * @param {Object} params - The parameters for changing the language.\r\n   * @param {string} params.languageId - The ID of the language to change to.\r\n   *\r\n   * @returns {Observable<Object>} - An observable that emits the updated user data.\r\n   */\r\n  changeLanguage ({\r\n    languageId\r\n  }: ChangeLanguageIn) {\r\n    return this.httpClient.put<ApiSuccess<MeOut>>(`${this.url}/auth/me`, {\r\n      language_id: languageId\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}
+                }] }, { type: i1.CookieService }, { type: i2.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-security.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam/ngx-services/src/lib/apis/api-security.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { ApiSuccess } from './models/api.models'\r\nimport {\r\n  ChangeLanguageIn,\r\n  CreateSessionIn,\r\n  CreateSessionOut,\r\n  GetUserOut,\r\n  LoginIn,\r\n  LoginOut,\r\n  MeOut\r\n} from './models/api-security.types'\r\nimport { HttpClient, HttpHeaders } from '@angular/common/http'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { map, Observable, tap } from 'rxjs'\r\nimport { CookieService } from 'ngx-cookie-service'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiSecurityService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private cookie: CookieService,\r\n    private http: HttpClient,\r\n  ) {}\r\n\r\n  /**\r\n   * Retrieves the API security URL from the environments configuration.\r\n   *\r\n   * @return {string} The API security URL.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiSecurityUrl\r\n  }\r\n\r\n  /**\r\n   * Authenticates a user with the provided credentials and role.\r\n   *\r\n   * @param {Object} param0 - The login input object.\r\n   * @param {string} param0.username - The username of the user.\r\n   * @param {string} param0.password - The password of the user.\r\n   * @param {string} param0.role - The role of the user.\r\n   * @return {Observable<LoginOut>} An observable emitting the login output object.\r\n   */\r\n  login ({\r\n    username,\r\n    password,\r\n    role,\r\n  }: LoginIn): Observable<LoginOut> {\r\n    return this.http.post<ApiSuccess<LoginOut>>(`${this.url}/auth/login`, {\r\n      system_name: 'CRA',\r\n      username,\r\n      password,\r\n      role,\r\n    }).pipe(\r\n      map(({ data }) => data),\r\n      tap(({ access_token }) => this.cookie.set(this.environments.tokenName, access_token, { path: '/' }))\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Logs out the current user by making a POST request to the logout endpoint.\r\n   *\r\n   * This method deletes all cookies after a successful logout.\r\n   *\r\n   * @return {Observable<{}>} An observable that emits the server's response to the logout request.\r\n   */\r\n  logout (): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/auth/logout`, null)\r\n      .pipe(\r\n        map(({ data }) => data),\r\n        tap(() => this.cookie.deleteAll('/'))\r\n      )\r\n  }\r\n\r\n  /**\r\n   * Creates a new session for a specified model.\r\n   *\r\n   * @param {Object} params - The parameters for creating the session.\r\n   * @param {string} params.modelType - The type of the model.\r\n   * @param {string} params.modelId - The ID of the model.\r\n   * @param {string} [params.token] - Optional authorization token.\r\n   *\r\n   * @return {Observable<CreateSessionOut>} An observable containing the created session details.\r\n   */\r\n  createSession ({\r\n    modelType,\r\n    modelId,\r\n    token,\r\n  }: CreateSessionIn): Observable<CreateSessionOut> {\r\n    let headers = new HttpHeaders({})\r\n\r\n    if (token)\r\n      headers = headers.set('Authorization', `Bearer ${token}`)\r\n\r\n    return this.http.post<ApiSuccess<CreateSessionOut>>(\r\n      `${this.url}/sessions`, {\r\n        model_type: modelType,\r\n        model_id: modelId,\r\n      }, {\r\n        headers\r\n      }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the authenticated user's information.\r\n   * Sends a GET request to the endpoint '/auth/me' to retrieve information\r\n   * about the currently authenticated user.\r\n   *\r\n   * @return {Observable<MeOut>} An observable that emits the authenticated user's data.\r\n   */\r\n  me (): Observable<MeOut> {\r\n    return this.http.get<ApiSuccess<MeOut>>(`${this.url}/auth/me`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the authenticated user's details from the server.\r\n   *\r\n   * @param token The JWT token used for authorization.\r\n   * @return An Observable that emits the user's details encapsulated in a MeOut object.\r\n   */\r\n  otherMe (token: string): Observable<MeOut> {\r\n    return this.http.get<ApiSuccess<MeOut>>(`${this.url}/auth/me`, {\r\n      headers: {\r\n        Authorization: `Bearer ${token}`\r\n      }\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a user by their unique ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the user to be fetched.\r\n   * @return {Observable<GetUserOut>} An observable containing the user information.\r\n   */\r\n  user (id: number): Observable<GetUserOut> {\r\n    return this.http.get<ApiSuccess<GetUserOut>>(`${this.url}/users/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Changes the language for the authenticated user.\r\n   *\r\n   * @param {Object} params - The input parameters for changing the language.\r\n   * @param {string} params.languageId - The ID of the new language to be set.\r\n   * @return {Observable<ApiSuccess<MeOut>>} An observable that emits the result of the language change request.\r\n   */\r\n  changeLanguage ({\r\n    languageId\r\n  }: ChangeLanguageIn): Observable<MeOut> {\r\n    return this.http.put<ApiSuccess<MeOut>>(`${this.url}/auth/me`, {\r\n      language_id: languageId\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

package/esm2020/lib/apis/models/api-catalog.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/apis/models/api-companies.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam/ngx-services/src/lib/apis/models/api-companies.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { LaravelModel } from './api.models'\r\nimport { Currency, State } from './api-catalog.interfaces'\r\n\r\nexport interface Account extends LaravelModel {\r\n  number: string\r\n  description: string\r\n  account_type_id: number\r\n  country_id: number\r\n  is_default: boolean\r\n}\r\n\r\nexport interface Company extends LaravelModel {\r\n  id: number\r\n  created_at: string\r\n  updated_at: string\r\n  name: string\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone: string\r\n  state: string\r\n  city: string\r\n  county_name: string\r\n  zip_code: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  is_active: boolean\r\n}\r\n\r\nexport interface CompanyCountry extends LaravelModel {\r\n  company_id: number\r\n  country_id: number\r\n  headquarters_city_code: string\r\n  lp_code: string\r\n  company: Company\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone_code: string\r\n  contact_phone_number: string\r\n  state: string\r\n  city: string\r\n  zip_code: string\r\n  county_name: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n}\r\n\r\nexport interface CompanyCountryTax extends LaravelModel {\r\n  code: string\r\n  name: string\r\n  percentage: number\r\n  company_country_id: number\r\n  shipment_scopes: number[]\r\n  base_percentage: number\r\n  tax_type: string\r\n}\r\n\r\nexport interface CountryCurrencyRate extends CountryReferenceCurrency {\r\n  rate: number\r\n}\r\n\r\nexport interface CountryReference extends LaravelModel {\r\n  language_id: number\r\n  decimal_point: number\r\n  decimal_separator: string\r\n  thousands_separator: string\r\n  use_billing: boolean\r\n  use_payments: boolean\r\n  restricted_import_countries: number[]\r\n  currency_id: number\r\n  max_quantity_document_piece: number\r\n  max_quantity_package_piece: number\r\n  weight_restriction_piece: number\r\n  restriction_shipment: number\r\n  restriction_dimension: number\r\n  max_declared_value: number\r\n  territories: number[]\r\n  some_openings: boolean\r\n  locale: string\r\n  country_id: number\r\n  label_printer_name: string\r\n  receipt_printer_name: string\r\n  others_printer_name: string\r\n}\r\n\r\nexport interface CountryReferenceCurrency extends LaravelModel {\r\n  country_id: number\r\n  currency_id: number\r\n  is_local: boolean\r\n  can_transact: boolean\r\n  code: string\r\n  name: string\r\n  is_default: boolean\r\n  is_declared_insured: boolean\r\n  currency: Currency\r\n}\r\n\r\nexport interface Employee extends LaravelModel {\r\n  name: string\r\n  last_name: string\r\n  number: string\r\n  company_id: number\r\n  country_id: number\r\n  external: boolean\r\n  phone_code: string\r\n  phone_number: string\r\n  is_active: boolean\r\n  password: string\r\n  roles: string[]\r\n  locations: Location[]\r\n}\r\n\r\nexport interface Exchange extends LaravelModel {\r\n  company_country_currency_id: number\r\n  valid_since: string\r\n  valid_until: string | null\r\n  value: number\r\n  type: string\r\n}\r\n\r\nexport interface Installation extends LaravelModel {\r\n  system_id: number\r\n  mac_address: string\r\n  ip_address: string\r\n  location_id: number\r\n}\r\n\r\nexport interface Location extends LaravelModel {\r\n  name: string\r\n  contact_name: string\r\n  email: string\r\n  facility_code: string\r\n  location_code: string\r\n  type: string\r\n  state_name: string\r\n  state_id: number\r\n  state_code: string\r\n  city_name: string\r\n  zip_code: string\r\n  county_name: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  service_area_code: string\r\n  iata_code: string\r\n  phone_code: string\r\n  phone_number: string\r\n  gmt_offset: string\r\n  company_country_id: number\r\n  country_zone_id: number\r\n  country_region_id: number\r\n  management_area_id: number\r\n  google_maps_id: string\r\n  route_number: string\r\n  locker_enabled: boolean\r\n  queue_manager_enabled: boolean\r\n  commission_account: string\r\n  service_point_id: string\r\n  is_occurs: boolean\r\n  accounts: Account[]\r\n  company_country: CompanyCountry\r\n  state: State\r\n}\r\n\r\nexport interface LocationEmployee extends LaravelModel {\r\n  location_id: number\r\n  employee_id: number\r\n  is_active: boolean\r\n  is_supervisor: boolean\r\n  employee: Employee\r\n  location: Location\r\n}\r\n\r\nexport interface Parameter {\r\n  name: string\r\n  value: any\r\n  status?: string\r\n}\r\n\r\nexport interface SupplyEntity extends LaravelModel {\r\n  name: string\r\n  description: string\r\n  country_id: number\r\n  enabled_for_dropoff: boolean\r\n  supply_type: SupplyType\r\n  supply_packing: SupplyPacking\r\n}\r\n\r\nexport interface SupplyPacking extends LaravelModel {\r\n  value: number\r\n  weight: number\r\n  height: number\r\n  depth: number\r\n  width: number\r\n  emobile_code: string | null\r\n}\r\n\r\nexport interface SupplyType extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface Workflow {\r\n  page: string\r\n  enabled: boolean\r\n}\r\nexport interface LocationEmployee extends LaravelModel {\r\n  location_id: number\r\n  employee_id: number\r\n  is_active: boolean\r\n  is_supervisor: boolean\r\n  employee: Employee\r\n  location: Location\r\n}\r\n\r\nexport interface Employee extends LaravelModel {\r\n  name: string\r\n  last_name: string\r\n  number: string\r\n  company_id: number\r\n  country_id: number\r\n  external: boolean\r\n  phone_code: string\r\n  phone_number: string\r\n  is_active: boolean\r\n  password: string\r\n  roles: string[]\r\n  locations: Location[]\r\n}\r\n\r\nexport interface Location extends LaravelModel {\r\n  name: string\r\n  contact_name: string\r\n  email: string\r\n  facility_code: string\r\n  location_code: string\r\n  type: string\r\n  state_name: string\r\n  state_id: number\r\n  state_code: string\r\n  city_name: string\r\n  zip_code: string\r\n  county_name: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  service_area_code: string\r\n  iata_code: string\r\n  phone_code: string\r\n  phone_number: string\r\n  gmt_offset: string\r\n  company_country_id: number\r\n  country_zone_id: number\r\n  country_region_id: number\r\n  management_area_id: number\r\n  google_maps_id: string\r\n  route_number: string\r\n  locker_enabled: boolean\r\n  queue_manager_enabled: boolean\r\n  commission_account: string\r\n  service_point_id: string\r\n  is_occurs: boolean\r\n  accounts: Account[]\r\n  company_country: CompanyCountry\r\n  state: State\r\n}\r\n\r\nexport interface Company extends LaravelModel {\r\n  id: number\r\n  created_at: string\r\n  updated_at: string\r\n  name: string\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone: string\r\n  state: string\r\n  city: string\r\n  county_name: string\r\n  zip_code: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  is_active: boolean\r\n}\r\n\r\nexport interface CompanyCountry extends LaravelModel {\r\n  company_id: number\r\n  country_id: number\r\n  headquarters_city_code: string\r\n  lp_code: string\r\n  company: Company\r\n  contact_name: string\r\n  contact_email: string\r\n  contact_phone_code: string\r\n  contact_phone_number: string\r\n  state: string\r\n  city: string\r\n  zip_code: string\r\n  county_name: string\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n}\r\n\r\nexport interface Installation extends LaravelModel {\r\n  system_id: number\r\n  mac_address: string\r\n  ip_address: string\r\n  location_id: number\r\n}\r\n\r\nexport interface SupplyEntity extends LaravelModel {\r\n  name: string\r\n  description: string\r\n  country_id: number\r\n  enabled_for_dropoff: boolean\r\n  supply_type: SupplyType\r\n  supply_packing: SupplyPacking\r\n}\r\n\r\nexport interface SupplyType extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface SupplyPacking extends LaravelModel {\r\n  value: number\r\n  weight: number\r\n  height: number\r\n  depth: number\r\n  width: number\r\n  emobile_code: string | null\r\n}\r\n\r\nexport interface Employee extends LaravelModel {\r\n  name: string\r\n  last_name: string\r\n  number: string\r\n  company_id: number\r\n  country_id: number\r\n  external: boolean\r\n  phone_code: string\r\n  phone_number: string\r\n  is_active: boolean\r\n  password: string\r\n  roles: string[]\r\n  locations: Location[]\r\n}\r\n\r\nexport interface CountryReferenceCurrency extends LaravelModel {\r\n  country_id: number\r\n  currency_id: number\r\n  is_local: boolean\r\n  can_transact: boolean\r\n  code: string\r\n  name: string\r\n  is_default: boolean\r\n  is_declared_insured: boolean\r\n  currency: Currency\r\n}\r\n\r\nexport interface CompanyCountryTax extends LaravelModel {\r\n  code: string\r\n  name: string\r\n  percentage: number\r\n  company_country_id: number\r\n  shipment_scopes: number[]\r\n  base_percentage: number\r\n  tax_type: string\r\n}\r\n\r\nexport interface Exchange extends LaravelModel {\r\n  company_country_currency_id: number\r\n  valid_since: string\r\n  valid_until: string | null\r\n  value: number\r\n  type: string\r\n}\r\n\r\nexport interface Parameter {\r\n  name: string\r\n  value: any\r\n  status?: string\r\n}\r\n\r\nexport interface CountryReference extends LaravelModel {\r\n  language_id: number\r\n  decimal_point: number\r\n  decimal_separator: string\r\n  thousands_separator: string\r\n  use_billing: boolean\r\n  use_payments: boolean\r\n  restricted_import_countries: number[]\r\n  currency_id: number\r\n  max_quantity_document_piece: number\r\n  max_quantity_package_piece: number\r\n  weight_restriction_piece: number\r\n  restriction_shipment: number\r\n  restriction_dimension: number\r\n  max_declared_value: number\r\n  territories: number[]\r\n  some_openings: boolean\r\n  locale: string\r\n  country_id: number\r\n  label_printer_name: string\r\n  receipt_printer_name: string\r\n  others_printer_name: string\r\n}\r\n\r\nexport interface Workflow {\r\n  page: string\r\n  enabled: boolean\r\n}\r\n"]}

package/esm2020/lib/apis/models/api-companies.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/apis/models/api-security.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/apis/models/api-security.types.mjs

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

package/esm2020/lib/apis/models/api.models.mjs

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