@experteam-mx/ngx-services 0.1.1 → 15.1.0

package/fesm2015/experteam-mx-ngx-services.mjs

@@ -1,9 +1,10 @@
 import * as i0 from '@angular/core';
 import { NgModule, Injectable, Inject } from '@angular/core';
 import * as i1 from '@angular/common/http';
-import { HttpClientModule, HttpHeaders } from '@angular/common/http';
-import { map, tap } from 'rxjs';
-import * as i2 from 'ngx-cookie-service';
+import { HttpClientModule, HttpParams, HttpHeaders, HttpResponse } from '@angular/common/http';
+import { map, mergeMap, forkJoin, tap, of } from 'rxjs';
+import * as i1$1 from 'ngx-cookie-service';
+import { tap as tap$1 } from 'rxjs/operators';
 
 class NgxServicesModule {
     /**
@@ -39,62 +40,380 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 }]
         }] });
 
+/**
+ * Convert an object of key-value pairs into a URL query string.
+ *
+ * @param {Object} params - The key-value pairs to converted into a query string.
+ *
+ * @return {string} - The generated query string.
+ */
+const queryString = (params) => {
+    let queryElements = [];
+    Object.entries(params).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            const arrayQuery = value
+                .map((item) => `${encodeURIComponent(key)}=${encodeURIComponent(item)}`)
+                .join('&');
+            queryElements.push(arrayQuery);
+        }
+        else {
+            const encodedQuery = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+            queryElements.push(encodedQuery);
+        }
+    });
+    const queryString = queryElements.join('&');
+    return queryString.length ? `?${queryString}` : '';
+};
+/**
+ * Creates an instance of HttpParams using the provided params object.
+ *
+ * @param {Object} params - The object containing the params to the HttpParams constructor.
+ *
+ * @returns {HttpParams} - An instance of HttpParams created from the params object.
+ */
+const httpParams = (params) => new HttpParams({
+    fromObject: params
+});
+/**
+ * Returns the headers for generating PDF files.
+ *
+ * @param {string} format - The format of the headers, 'object' or 'http_header'.
+ *
+ * @returns {HttpHeaders | { [header: string]: string | string[] }} - The headers for generating PDF files.
+ */
+const pdfHeaders = (format = 'object') => {
+    const headers = {
+        'Accept': 'application/pdf'
+    };
+    return format === 'object'
+        ? headers
+        : new HttpHeaders(headers);
+};
+/**
+ * Returns the headers for generating XML files.
+ *
+ * @param {string} format - The format of the headers, 'object' or 'http_header'.
+ *
+ * @returns {HttpHeaders | { [header: string]: string | string[] }} - The headers for generating XML files.
+ */
+const xmlHeaders = (format = 'object') => {
+    const headers = {
+        'Accept': 'application/xml',
+    };
+    return format === 'object'
+        ? headers
+        : new HttpHeaders(headers);
+};
+
+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) => {
+                var _a, _b;
+                return (Object.assign(Object.assign({}, country_reference_currency), { rate: (_b = (_a = exchangesData.exchanges[0]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 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 }];
+    } });
+
 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.
-     *
-     * @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.
+     * Authenticates a user with the provided credentials and role.
      *
-     * @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,
         }, {
@@ -102,54 +421,53 @@ 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`)
-            .pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves user information from the API.
-     *
-     * @param {GetUserIn} user - The user object containing the user ID.
-     *
-     * @returns {Observable<GetUserOut>} - An observable that emits the retrieved user data.
-     */
-    user({ userId }) {
-        return this.httpClient.get(`${this.url}/users/${userId}`)
+        return this.http.get(`${this.url}/auth/me`)
             .pipe(map(({ data }) => data));
     }
     /**
-     * Get user information
+     * Fetches the authenticated user's details from the server.
      *
-     * @param {string} token - The user's authentication token
-     *
-     * @return {Observable<MeOut>} - An observable that emits the user's information
+     * @param token The JWT token used for authorization.
+     * @return An Observable that emits the user's details encapsulated in a MeOut object.
      */
-    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$1.CookieService }, { token: i1.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,
@@ -160,41 +478,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
         return [{ type: undefined, decorators: [{
                         type: Inject,
                         args: ['env']
-                    }] }, { type: i1.HttpClient }, { type: i2.CookieService }];
+                    }] }, { type: i1$1.CookieService }, { type: i1.HttpClient }];
     } });
 
-class ApiTokenInterceptor {
-    constructor(cookie) {
-        this.cookie = cookie;
-    }
-    /**
-     * Intercepts the HTTP request and adds the Authorization header.
-     *
-     * @param {HttpRequest<unknown>} request - The HTTP request to intercept.
-     * @param {HttpHandler} next - The next HTTP handler in the chain.
-     *
-     * @returns {Observable<HttpEvent<unknown>>} - An observable containing the HTTP event.
-     */
-    intercept(request, next) {
-        if (request.headers.has('Authorization'))
-            return next.handle(request);
-        const token = this.cookie.get('tokenCRA');
-        if (!token)
-            return next.handle(request);
-        request = request.clone({
-            setHeaders: {
-                Authorization: `Bearer ${token}`
-            }
-        });
-        return next.handle(request);
-    }
-}
-ApiTokenInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiTokenInterceptor, deps: [{ token: i2.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
-ApiTokenInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiTokenInterceptor });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiTokenInterceptor, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i2.CookieService }]; } });
-
 class ApiHeadersInterceptor {
     /**
      * Intercepts HTTP requests and adds common headers.
@@ -227,49 +513,79 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             type: Injectable
         }] });
 
-/**
- * Convert an object of key-value pairs into a URL query string.
- *
- * @param {Object} params - The key-value pairs to converted into a query string.
- *
- * @return {string} - The generated query string.
- */
-const queryString = (params) => {
-    const query = Object.keys(params)
-        .map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(params[k])}`)
-        .join('&');
-    return query.length ? `?${query}` : '';
-};
-/**
- * Returns the headers for generating PDF files.
- *
- * @param {string} format - The format of the headers, 'object' or 'http_header'.
- *
- * @returns {HttpHeaders | { [header: string]: string | string[] }} - The headers for generating PDF files.
- */
-const pdfHeaders = (format = 'object') => {
-    const headers = {
-        'Accept': 'application/pdf'
-    };
-    return format === 'object'
-        ? headers
-        : new HttpHeaders(headers);
-};
-/**
- * Returns the headers for generating XML files.
- *
- * @param {string} format - The format of the headers, 'object' or 'http_header'.
- *
- * @returns {HttpHeaders | { [header: string]: string | string[] }} - The headers for generating XML files.
- */
-const xmlHeaders = (format = 'object') => {
-    const headers = {
-        'Accept': 'application/xml',
-    };
-    return format === 'object'
-        ? headers
-        : new HttpHeaders(headers);
-};
+class ApiTokenInterceptor {
+    constructor(environments, cookie) {
+        this.environments = environments;
+        this.cookie = cookie;
+    }
+    /**
+     * Intercepts the HTTP request and adds the Authorization header.
+     *
+     * @param {HttpRequest<unknown>} request - The HTTP request to intercept.
+     * @param {HttpHandler} next - The next HTTP handler in the chain.
+     *
+     * @returns {Observable<HttpEvent<unknown>>} - An observable containing the HTTP event.
+     */
+    intercept(request, next) {
+        if (request.headers.has('Authorization'))
+            return next.handle(request);
+        const token = this.cookie.get(this.environments.tokenName);
+        if (!token)
+            return next.handle(request);
+        request = request.clone({
+            setHeaders: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        return next.handle(request);
+    }
+}
+ApiTokenInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiTokenInterceptor, deps: [{ token: 'env' }, { token: i1$1.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+ApiTokenInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiTokenInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiTokenInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['env']
+                    }] }, { type: i1$1.CookieService }];
+    } });
+
+const DEFAULT_TTL = 10000; // ttl in ms
+class HttpCachingInterceptor {
+    constructor(envs) {
+        this.envs = envs;
+        this.cache = new Map();
+    }
+    intercept(req, next) {
+        if (req.method !== 'GET')
+            return next.handle(req);
+        const cached = this.cache.get(req.urlWithParams);
+        if (cached) {
+            const isExpired = Date.now() > cached.ttl;
+            if (!isExpired)
+                return of(cached.res);
+            this.cache.delete(req.urlWithParams); // If expired, remove the entry from cache
+        }
+        return next.handle(req).pipe(tap$1((res) => {
+            var _a;
+            if (!(res instanceof HttpResponse))
+                return;
+            const ttl = Date.now() + ((_a = this.envs.cacheTtl) !== null && _a !== void 0 ? _a : DEFAULT_TTL);
+            this.cache.set(req.urlWithParams, { res, ttl });
+        }));
+    }
+}
+HttpCachingInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpCachingInterceptor, deps: [{ token: 'env' }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpCachingInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpCachingInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpCachingInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: ['env']
+                    }] }];
+    } });
 
 /*
  * Public API Surface of ngx-services
@@ -279,5 +595,5 @@ const xmlHeaders = (format = 'object') => {
  * Generated bundle index. Do not edit.
  */
 
-export { ApiHeadersInterceptor, ApiSecurityService, ApiTokenInterceptor, NgxServicesModule, pdfHeaders, queryString, xmlHeaders };
+export { ApiCompaniesService, ApiHeadersInterceptor, ApiSecurityService, ApiTokenInterceptor, HttpCachingInterceptor, NgxServicesModule, httpParams, pdfHeaders, queryString, xmlHeaders };
 //# sourceMappingURL=experteam-mx-ngx-services.mjs.map