@experteam-mx/ngx-services 20.0.0 → 20.0.1

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

@@ -0,0 +1,53 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiEventsService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Gets the API endpoint URL for Events from the environments configuration.
+     *
+     * @return {string} The URL for the Events API. Returns an empty string if not defined.
+     */
+    get url() {
+        return this.environments.apiEventsUrl ?? '';
+    }
+    /**
+     * Sends a request to start an event
+     *
+     * @param {OperationModuleStartIn} body - The event information to be submitted.
+     * @return {Observable<OperationModuleOut>} An Observable emitting the server's response containing the created event details.
+     */
+    postOperationModulesStart(body) {
+        return this.http.post(`${this.url}/operation-modules/start`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates the discount information for a specific item.
+     *
+     * @param {number} id - The unique identifier of the item whose event is to be updated.
+     * @param {OperationModuleEndIn} body - The payload containing the updated event details.
+     * @return {Observable<OperationModuleOut>} An observable emitting the updated event details.
+     */
+    putOperationModulesEnd(id, body) {
+        return this.http.put(`${this.url}/operation-modules/${id}/end`, body)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiEventsService, 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: ApiEventsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiEventsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,208 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiInventoriesService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the Inventories API from the environment configurations.
+     *
+     * @return {string} The URL of the Inventories API.
+     */
+    get url() {
+        return this.environments.apiInventoriesUrl ?? '';
+    }
+    /**
+     * Retrieves a list of checkpoints based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the checkpoints.
+     * @returns {Observable<CheckpointsOut>} The list of checkpoints.
+     */
+    getCheckpoints(params) {
+        return this.http.get(`${this.url}/checkpoints`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of checkpoint event reasons based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the checkpoint event reasons.
+     * @returns {Observable<CheckpointEventReasonsOut>} The list of checkpoint event reasons.
+     */
+    getCheckpointEventReasons(params) {
+        return this.http.get(`${this.url}/checkpoint-event-reasons`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of incidents based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the incidents.
+     * @returns {Observable<IncidentsOut>} An observable that emits the list of incidents.
+     */
+    getIncidents(params) {
+        return this.http.get(`${this.url}/incidents`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the incident details based on the provided incident ID.
+     *
+     * @param {number} id - The identifier of the incident record to get detail.
+     * @return {Observable<IncidentOut>} An observable that emits the detail incident data.
+     */
+    getIncident(id) {
+        return this.http.get(`${this.url}/incidents/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new incident.
+     *
+     * @param {IncidentIn} body - The data for the new incident.
+     * @returns {Observable<IncidentOut>} An observable the created incident detail.
+     */
+    postIncident(body) {
+        return this.http.post(`${this.url}/incidents`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing incident.
+     *
+     * @param {number} id - The identifier of the incident record to update.
+     * @param {IncidentIn} body - The incident data to be updated.
+     * @returns {Observable<IncidentOut>} An observable detail of the updated incident.
+     */
+    putIncident(id, body) {
+        return this.http.put(`${this.url}/incidents/${id}`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Delete an existing incident.
+     *
+     * @param {number} id - The unique identifier of the incident to be deleted.
+     * @returns {Observable<IncidentOut>} An observable that emits the result of the delete incident.
+     */
+    deleteIncident(id) {
+        return this.http.delete(`${this.url}/incidents/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of incident reasons based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the incident reasons.
+     * @returns {Observable<IncidentReasonsOut>} An observable that emits the list of incident reasons.
+     */
+    getIncidentReasons(params) {
+        return this.http.get(`${this.url}/incident-reasons`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the incident reason details based on the provided incident reason ID.
+     *
+     * @param {number} id - The identifier of the incident reason record to get detail.
+     * @return {Observable<IncidentReasonOut>} An observable that emits the detail incident reason data.
+     */
+    getIncidentReason(id) {
+        return this.http.get(`${this.url}/incident-reasons/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new incident reason.
+     *
+     * @param {IncidentReasonIn} body - The data for the new incident reason.
+     * @returns {Observable<IncidentReasonOut>} An observable the created incident reason detail.
+     */
+    postIncidentReason(body) {
+        return this.http.post(`${this.url}/incident-reasons`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing incident reason.
+     *
+     * @param {number} id - The identifier of the incident reason record to update.
+     * @param {IncidentIn} body - The incident reason data to be updated.
+     * @returns {Observable<IncidentReasonOut>} An observable detail of the updated incident reason.
+     */
+    putIncidentReason(id, body) {
+        return this.http.put(`${this.url}/incident-reasons/${id}`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Delete an existing incident reason.
+     *
+     * @param {number} id - The unique identifier of the incident reason to be deleted.
+     * @returns {Observable<IncidentReasonOut>} An observable that emits the result of the delete incident reason.
+     */
+    deleteIncidentReason(id) {
+        return this.http.delete(`${this.url}/incident-reasons/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of incident reason complements based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the incident reason complements.
+     * @returns {Observable<IncidentReasonComplementsOut>} An observable that emits the list of incident reason complements.
+     */
+    getIncidentReasonComplements(params) {
+        return this.http.get(`${this.url}/incident-reason-complements`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new incident reason complement.
+     *
+     * @param {IncidentReasonIn} body - The data for the new incident reason complement.
+     * @returns {Observable<IncidentReasonComplementOut>} An observable the created incident reason complement detail.
+     */
+    postIncidentReasonComplement(body) {
+        return this.http.post(`${this.url}/incident-reason-complements`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing incident reason complement.
+     *
+     * @param {number} id - The identifier of the incident reason complement record to update.
+     * @param {IncidentIn} body - The incident reason complement data to be updated.
+     * @returns {Observable<IncidentReasonComplementOut>} An observable detail of the updated incident reason complement.
+     */
+    putIncidentReasonComplement(id, body) {
+        return this.http.put(`${this.url}/incident-reason-complements/${id}`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Delete an existing incident reason complement.
+     *
+     * @param {number} id - The unique identifier of the incident reason complement to be deleted.
+     * @returns {Observable<IncidentReasonComplementOut>} An observable that emits the result of the delete incident reason complement.
+     */
+    deleteIncidentReasonComplement(id) {
+        return this.http.delete(`${this.url}/incident-reason-complements/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Posts packages that are currently in stock.
+     *
+     * @param body - The input data containing package stock information
+     * @returns {Observable<PackagesInStockOut>} An Observable that emits the packages in stock output data
+     *
+     * @remarks
+     * This method sends a POST request to the `/packages/in-stock` endpoint and
+     * extracts the data property from the API success response.
+     */
+    postPackagesInStock(body) {
+        return this.http.post(`${this.url}/packages/in-stock`, body)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInventoriesService, 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: ApiInventoriesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInventoriesService, 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-inventories.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-inventories.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAIlD,OAAO,EAAE,GAAG,EAAc,MAAM,MAAM,CAAA;;;AAMtC,MAAM,OAAO,qBAAqB;IAEP;IACf;IAFV,YACyB,YAAyB,EACxC,IAAgB;QADD,iBAAY,GAAZ,YAAY,CAAa;QACxC,SAAI,GAAJ,IAAI,CAAY;IACtB,CAAC;IAEL;;;;OAIG;IACH,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,YAAY,CAAC,iBAAiB,IAAI,EAAE,CAAA;IAClD,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAE,MAAmB;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA6B,GAAG,IAAI,CAAC,GAAG,cAAc,EAAE;YAC1E,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAE,MAAmB;QAC5C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAwC,GAAG,IAAI,CAAC,GAAG,2BAA2B,EAAE;YAClG,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAE,MAAmB;QAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA2B,GAAG,IAAI,CAAC,GAAG,YAAY,EAAE;YACtE,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAE,EAAU;QACrB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA0B,GAAG,IAAI,CAAC,GAAG,cAAc,EAAE,EAAE,CAAC;aACzE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAE,IAAgB;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA0B,GAAG,IAAI,CAAC,GAAG,YAAY,EACpE,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAE,EAAU,EAAE,IAAgB;QACvC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA0B,GAAG,IAAI,CAAC,GAAG,cAAc,EAAE,EAAE,EACzE,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAE,EAAU;QACxB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAA0B,GAAG,IAAI,CAAC,GAAG,cAAc,EAAE,EAAE,CAAC;aAC5E,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,kBAAkB,CAAE,MAAmB;QACrC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAiC,GAAG,IAAI,CAAC,GAAG,mBAAmB,EAAE;YACnF,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAE,EAAU;QAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAgC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE,EAAE,CAAC;aACtF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,kBAAkB,CAAE,IAAsB;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAgC,GAAG,IAAI,CAAC,GAAG,mBAAmB,EACjF,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;;OAMG;IACH,iBAAiB,CAAE,EAAU,EAAE,IAAsB;QACnD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAgC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE,EAAE,EACtF,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;OAKG;IACH,oBAAoB,CAAE,EAAU;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAgC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE,EAAE,CAAC;aACzF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,4BAA4B,CAAE,MAAmB;QAC/C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA2C,GAAG,IAAI,CAAC,GAAG,8BAA8B,EAAE;YACxG,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,4BAA4B,CAAE,IAAgC;QAC5D,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA0C,GAAG,IAAI,CAAC,GAAG,8BAA8B,EACtG,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;;OAMG;IACH,2BAA2B,CAAE,EAAU,EAAE,IAAgC;QACvE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA0C,GAAG,IAAI,CAAC,GAAG,gCAAgC,EAAE,EAAE,EAC3G,IAAI,CACL,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACjC,CAAC;IAED;;;;;OAKG;IACH,8BAA8B,CAAE,EAAU;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAA0C,GAAG,IAAI,CAAC,GAAG,gCAAgC,EAAE,EAAE,CAAC;aAC9G,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;;;;;OASG;IACH,mBAAmB,CAAE,IAAuB;QAC1C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiC,GAAG,IAAI,CAAC,GAAG,oBAAoB,EAAE,IAAI,CAAC;aACzF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;wGA1NU,qBAAqB,kBAEtB,KAAK;4GAFJ,qBAAqB,cAFpB,MAAM;;4FAEP,qBAAqB;kBAHjC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAGI,MAAM;2BAAC,KAAK","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport { map, Observable } from 'rxjs'\r\nimport { CheckpointEventReasonsOut, CheckpointsOut, IncidentIn, IncidentOut, IncidentReasonComplementIn, IncidentReasonComplementOut, IncidentReasonComplementsOut, IncidentReasonIn, IncidentReasonOut, IncidentReasonsOut, IncidentsOut, PackagesInStockIn, PackagesInStockOut } from './models/api-inventories.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInventoriesService {\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 Inventories API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the Inventories API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInventoriesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of checkpoints based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the checkpoints.\r\n   * @returns {Observable<CheckpointsOut>} The list of checkpoints.\r\n   */\r\n  getCheckpoints (params: QueryParams): Observable<CheckpointsOut> {\r\n    return this.http.get<ApiSuccess<CheckpointsOut>>(`${this.url}/checkpoints`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of checkpoint event reasons based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the checkpoint event reasons.\r\n   * @returns {Observable<CheckpointEventReasonsOut>} The list of checkpoint event reasons.\r\n   */\r\n  getCheckpointEventReasons (params: QueryParams): Observable<CheckpointEventReasonsOut> {\r\n    return this.http.get<ApiSuccess<CheckpointEventReasonsOut>>(`${this.url}/checkpoint-event-reasons`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of incidents based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the incidents.\r\n   * @returns {Observable<IncidentsOut>} An observable that emits the list of incidents.\r\n   */\r\n  getIncidents (params: QueryParams): Observable<IncidentsOut> {\r\n    return this.http.get<ApiSuccess<IncidentsOut>>(`${this.url}/incidents`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the incident details based on the provided incident ID.\r\n   *\r\n   * @param {number} id - The identifier of the incident record to get detail.\r\n   * @return {Observable<IncidentOut>} An observable that emits the detail incident data.\r\n   */\r\n  getIncident (id: Number): Observable<IncidentOut> {\r\n    return this.http.get<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new incident.\r\n   *\r\n   * @param {IncidentIn} body - The data for the new incident.\r\n   * @returns {Observable<IncidentOut>} An observable the created incident detail.\r\n   */\r\n  postIncident (body: IncidentIn): Observable<IncidentOut> {\r\n    return this.http.post<ApiSuccess<IncidentOut>>(`${this.url}/incidents`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing incident.\r\n   *\r\n   * @param {number} id - The identifier of the incident record to update.\r\n   * @param {IncidentIn} body - The incident data to be updated.\r\n   * @returns {Observable<IncidentOut>} An observable detail of the updated incident.\r\n   */\r\n  putIncident (id: Number, body: IncidentIn): Observable<IncidentOut> {\r\n    return this.http.put<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing incident.\r\n   *\r\n   * @param {number} id - The unique identifier of the incident to be deleted.\r\n   * @returns {Observable<IncidentOut>} An observable that emits the result of the delete incident.\r\n   */\r\n  deleteIncident (id: Number): Observable<IncidentOut> {\r\n    return this.http.delete<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of incident reasons based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the incident reasons.\r\n   * @returns {Observable<IncidentReasonsOut>} An observable that emits the list of incident reasons.\r\n   */\r\n  getIncidentReasons (params: QueryParams): Observable<IncidentReasonsOut> {\r\n    return this.http.get<ApiSuccess<IncidentReasonsOut>>(`${this.url}/incident-reasons`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the incident reason details based on the provided incident reason ID.\r\n   *\r\n   * @param {number} id - The identifier of the incident reason record to get detail.\r\n   * @return {Observable<IncidentReasonOut>} An observable that emits the detail incident reason data.\r\n   */\r\n  getIncidentReason (id: Number): Observable<IncidentReasonOut> {\r\n    return this.http.get<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new incident reason.\r\n   *\r\n   * @param {IncidentReasonIn} body - The data for the new incident reason.\r\n   * @returns {Observable<IncidentReasonOut>} An observable the created incident reason detail.\r\n   */\r\n  postIncidentReason (body: IncidentReasonIn): Observable<IncidentReasonOut> {\r\n    return this.http.post<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing incident reason.\r\n   *\r\n   * @param {number} id - The identifier of the incident reason record to update.\r\n   * @param {IncidentIn} body - The incident reason data to be updated.\r\n   * @returns {Observable<IncidentReasonOut>} An observable detail of the updated incident reason.\r\n   */\r\n  putIncidentReason (id: Number, body: IncidentReasonIn): Observable<IncidentReasonOut> {\r\n    return this.http.put<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing incident reason.\r\n   *\r\n   * @param {number} id - The unique identifier of the incident reason to be deleted.\r\n   * @returns {Observable<IncidentReasonOut>} An observable that emits the result of the delete incident reason.\r\n   */\r\n  deleteIncidentReason (id: Number): Observable<IncidentReasonOut> {\r\n    return this.http.delete<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of incident reason complements based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the incident reason complements.\r\n   * @returns {Observable<IncidentReasonComplementsOut>} An observable that emits the list of incident reason complements.\r\n   */\r\n  getIncidentReasonComplements (params: QueryParams): Observable<IncidentReasonComplementsOut> {\r\n    return this.http.get<ApiSuccess<IncidentReasonComplementsOut>>(`${this.url}/incident-reason-complements`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new incident reason complement.\r\n   *\r\n   * @param {IncidentReasonIn} body - The data for the new incident reason complement.\r\n   * @returns {Observable<IncidentReasonComplementOut>} An observable the created incident reason complement detail.\r\n   */\r\n  postIncidentReasonComplement (body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut> {\r\n    return this.http.post<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing incident reason complement.\r\n   *\r\n   * @param {number} id - The identifier of the incident reason complement record to update.\r\n   * @param {IncidentIn} body - The incident reason complement data to be updated.\r\n   * @returns {Observable<IncidentReasonComplementOut>} An observable detail of the updated incident reason complement.\r\n   */\r\n  putIncidentReasonComplement (id: Number, body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut> {\r\n    return this.http.put<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements/${id}`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing incident reason complement.\r\n   *\r\n   * @param {number} id - The unique identifier of the incident reason complement to be deleted.\r\n   * @returns {Observable<IncidentReasonComplementOut>} An observable that emits the result of the delete incident reason complement.\r\n   */\r\n  deleteIncidentReasonComplement (id: Number): Observable<IncidentReasonComplementOut> {\r\n    return this.http.delete<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Posts packages that are currently in stock.\r\n   *\r\n   * @param body - The input data containing package stock information\r\n   * @returns {Observable<PackagesInStockOut>} An Observable that emits the packages in stock output data\r\n   *\r\n   * @remarks\r\n   * This method sends a POST request to the `/packages/in-stock` endpoint and\r\n   * extracts the data property from the API success response.\r\n   */\r\n  postPackagesInStock (body: PackagesInStockIn): Observable<PackagesInStockOut> {\r\n    return this.http.post<ApiSuccess<PackagesInStockOut>>(`${this.url}/packages/in-stock`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}