@experteam-mx/ngx-services 18.8.22 → 18.8.24

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

@@ -0,0 +1,87 @@
+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 ApiExternalOperationsService {
+    http;
+    environment;
+    appKey;
+    constructor(http, environment) {
+        this.http = http;
+        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 ?? '';
+    }
+    /**
+     * Retrieves delivery confirmation details based on the provided OTP code.
+     *
+     * @param {string} otpCode - The OTP code used to search for delivery confirmation.
+     * @return {Observable<DeliveryConfirmationData>} An observable containing the delivery confirmation data.
+     */
+    getDeliveryConfirmation(otpCode) {
+        return this.http.get(`${this.url}/delivery-confirmation/search/${otpCode}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * 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.http.post(`${this.url}/delivery-confirmation/generate`, payload, {
+            headers: this.getAppKeyHeader(),
+        }).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.http.patch(`${this.url}/delivery-confirmation/completed/${keyOTP}`, null, {
+            headers: this.getAppKeyHeader(),
+            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.http.put(`${this.url}/delivery-confirmation/confirmation/${otp}`, body, {
+            headers: this.getAppKeyHeader(),
+        }).pipe(map(({ data }) => data));
+    }
+    getAppKeyHeader() {
+        return { ...(this.appKey && { AppKey: this.appKey }) };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiExternalOperationsService, 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: ApiExternalOperationsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiExternalOperationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-external-ops.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-external-ops.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAElD,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;;;AAcpC,MAAM,OAAO,4BAA4B;IAI7B;IACe;IAJjB,MAAM,CAAQ;IAEtB,YACU,IAAgB,EACD,WAAwB;QADvC,SAAI,GAAJ,IAAI,CAAY;QACD,gBAAW,GAAX,WAAW,CAAa;QAE/C,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC,wBAAwB,IAAI,EAAE,CAAA;IAC1D,CAAC;IAED;;;;;;OAMG;IACH,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,WAAW,CAAC,wBAAwB,IAAI,EAAE,CAAA;IACxD,CAAC;IAED;;;;;OAKG;IACI,uBAAuB,CAAE,OAAe;QAC7C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA4C,GAAG,IAAI,CAAC,GAAG,iCAAiC,OAAO,EAAE,CAAC;aACnH,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACI,gCAAgC,CAAE,OAAuC;QAC9E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACnB,GAAG,IAAI,CAAC,GAAG,iCAAiC,EAC5C,OAAO,EAAE;YACP,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE;SAChC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACpC,CAAC;IAED;;;;;;;OAOG;IACI,iCAAiC,CAAE,EACxC,MAAM,EACN,WAAW,GACoB;QAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CACpB,GAAG,IAAI,CAAC,GAAG,oCAAoC,MAAM,EAAE,EACvD,IAAI,EAAE;YACJ,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE;YAC/B,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE;SACtC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACpC,CAAC;IAED;;;;;;;OAOG;IACI,uBAAuB,CAAE,EAC9B,GAAG,EACH,GAAG,IAAI,EACgB;QACvB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAClB,GAAG,IAAI,CAAC,GAAG,uCAAuC,GAAG,EAAE,EACvD,IAAI,EAAE;YACJ,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE;SAChC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IACpC,CAAC;IAEO,eAAe;QACrB,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,CAAA;IACxD,CAAC;wGAvFU,4BAA4B,4CAK7B,KAAK;4GALJ,4BAA4B,cAF3B,MAAM;;4FAEP,4BAA4B;kBAHxC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAMI,MAAM;2BAAC,KAAK","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\nimport { Observable } from 'rxjs'\r\nimport { map } from 'rxjs/operators'\r\nimport { Environment } from '../ngx-services.models'\r\nimport {\r\n  DeliveryConfirmationCompleteIn,\r\n  DeliveryConfirmationGenerateIn,\r\n  DeliveryConfirmationGenerateOut,\r\n  DeliveryConfirmationIn,\r\n  DeliveryConfirmationSearchOut\r\n} from './models/api-external-ops.types'\r\nimport { ApiSuccess } from './models/api.models'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiExternalOperationsService {\r\n  private appKey: string\r\n\r\n  constructor (\r\n    private http: HttpClient,\r\n    @Inject('env') private environment: Environment\r\n  ) {\r\n    this.appKey = environment.apiExternalOperationsKey ?? ''\r\n  }\r\n\r\n  /**\r\n   * Getter method to retrieve the API's external operations URL.\r\n   * Fetches the URL from the `apiExternalOperationsUrl` property of the environment object.\r\n   * Defaults to an empty string if the property is undefined or null.\r\n   *\r\n   * @return {string} The external operations URL or an empty string if unavailable.\r\n   */\r\n  get url (): string {\r\n    return this.environment.apiExternalOperationsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves delivery confirmation details based on the provided OTP code.\r\n   *\r\n   * @param {string} otpCode - The OTP code used to search for delivery confirmation.\r\n   * @return {Observable<DeliveryConfirmationData>} An observable containing the delivery confirmation data.\r\n   */\r\n  public getDeliveryConfirmation (otpCode: string): Observable<DeliveryConfirmationSearchOut> {\r\n    return this.http.get<ApiSuccess<DeliveryConfirmationSearchOut>>(`${this.url}/delivery-confirmation/search/${otpCode}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Generates a delivery confirmation by sending the provided payload to the API.\r\n   *\r\n   * @param {DeliveryConfirmationGenerateIn} payload - The input payload required to generate the delivery confirmation.\r\n   * @return {Observable<DeliveryConfirmationGenerateOut>} An observable that emits the generated delivery confirmation data.\r\n   */\r\n  public postDeliveryConfirmationGenerate (payload: DeliveryConfirmationGenerateIn): Observable<DeliveryConfirmationGenerateOut> {\r\n    return this.http.post<ApiSuccess<DeliveryConfirmationGenerateOut>>(\r\n      `${this.url}/delivery-confirmation/generate`,\r\n      payload, {\r\n        headers: this.getAppKeyHeader(),\r\n      }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Confirms the completion of a delivery operation by making a PATCH request.\r\n   *\r\n   * @param {Object} input - The input parameters for the method.\r\n   * @param {string} input.operationId - The unique identifier of the delivery operation to be confirmed.\r\n   * @param {string} input.keyOTP - The one-time password (OTP) key associated with the delivery confirmation.\r\n   * @return {Observable<Object>} - An observable containing the response data from the API.\r\n   */\r\n  public patchDeliveryConfirmationComplete ({\r\n    keyOTP,\r\n    operationId,\r\n  }: DeliveryConfirmationCompleteIn): Observable<{}> {\r\n    return this.http.patch<ApiSuccess<{}>>(\r\n      `${this.url}/delivery-confirmation/completed/${keyOTP}`,\r\n      null, {\r\n        headers: this.getAppKeyHeader(),\r\n        params: { operation_id: operationId }\r\n      }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels a delivery confirmation by sending an OTP and additional data to the server.\r\n   *\r\n   * @param {Object} param0 - The parameter object containing the required properties.\r\n   * @param {string} param0.otp - The one-time password to authenticate the cancellation request.\r\n   * @param {Object} param0.body - Additional body data required for cancellation.\r\n   * @return {Observable<Object>} An observable that emits the server's response when the cancellation is processed.\r\n   */\r\n  public putDeliveryConfirmation ({\r\n    otp,\r\n    ...body\r\n  }: DeliveryConfirmationIn): Observable<{}> {\r\n    return this.http.put<ApiSuccess<{}>>(\r\n      `${this.url}/delivery-confirmation/confirmation/${otp}`,\r\n      body, {\r\n        headers: this.getAppKeyHeader(),\r\n      }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  private getAppKeyHeader () {\r\n    return { ...(this.appKey && { AppKey: this.appKey }) }\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,87 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Service to manage quote-related events.
+ *
+ * This service provides methods to retrieve, create, and get event types
+ * related to quote processes.
+ */
+export class ApiQuoteService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Base URL for the Quotes API.
+     */
+    get url() {
+        return this.environments.apiQuotesUrl ?? '';
+    }
+    /**
+     * Retrieves all registered events for a specific quote.
+     *
+     * @param id - Quote identifier.
+     * @param params - Optional query parameters such as pagination or filtering.
+     * @returns Observable containing the list of quote events.
+     *
+     * @example
+     * ```ts
+     * this.apiQuoteService.getQuoteEvents(10, { page: 1 })
+     *   .subscribe((events) => console.log(events))
+     * ```
+     */
+    getQuoteEvents(id, params) {
+        return this.http.get(`${this.url}/quotes/${id}/quote-events`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Registers a new event related to a specific quote.
+     *
+     * @param id - Quote identifier.
+     * @param body - Event payload to be created.
+     * @returns Observable containing the newly created event.
+     *
+     * @example
+     * ```ts
+     * const event: QuoteEventIn = { code: 'WON', note: 'Client approved' }
+     * this.apiQuoteService.postQuoteEvents(10, event)
+     *   .subscribe((response) => console.log(response))
+     * ```
+     */
+    postQuoteEvents(id, body) {
+        return this.http.post(`${this.url}/quotes/${id}/quote-events`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the available quote event types.
+     *
+     * @param params - Optional query parameters such as pagination or filtering.
+     * @returns Observable containing the list of event types.
+     *
+     * @example
+     * ```ts
+     * this.apiQuoteService.getQuoteEventTypes({ page: 1 })
+     *   .subscribe((types) => console.log(types))
+     * ```
+     */
+    getQuoteEventTypes(params) {
+        return this.http.get(`${this.url}/quote-event-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiQuoteService, 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: ApiQuoteService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiQuoteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXF1b3RlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9leHBlcnRlYW0tbXgvbmd4LXNlcnZpY2VzL3NyYy9saWIvYXBpcy9hcGktcXVvdGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUlsRCxPQUFPLEVBQUUsR0FBRyxFQUFjLE1BQU0sTUFBTSxDQUFBOzs7QUFHdEM7Ozs7O0dBS0c7QUFJSCxNQUFNLE9BQU8sZUFBZTtJQUVEO0lBQ2Y7SUFGVixZQUN5QixZQUF5QixFQUN4QyxJQUFnQjtRQURELGlCQUFZLEdBQVosWUFBWSxDQUFhO1FBQ3hDLFNBQUksR0FBSixJQUFJLENBQVk7SUFDdEIsQ0FBQztJQUVMOztPQUVHO0lBQ0gsSUFBSSxHQUFHO1FBQ0wsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLFlBQVksSUFBSSxFQUFFLENBQUE7SUFDN0MsQ0FBQztJQUVEOzs7Ozs7Ozs7Ozs7T0FZRztJQUNILGNBQWMsQ0FBRSxFQUFVLEVBQUUsTUFBbUI7UUFDN0MsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBNkIsR0FBRyxJQUFJLENBQUMsR0FBRyxXQUFXLEVBQUUsZUFBZSxFQUFFLEVBQUUsTUFBTSxFQUFFLENBQUM7YUFDbEcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUE7SUFDbEMsQ0FBQztJQUVEOzs7Ozs7Ozs7Ozs7O09BYUc7SUFDSCxlQUFlLENBQUUsRUFBVSxFQUFFLElBQWtCO1FBQzdDLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQTRCLEdBQUcsSUFBSSxDQUFDLEdBQUcsV0FBVyxFQUFFLGVBQWUsRUFBRSxJQUFJLENBQUM7YUFDNUYsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUE7SUFDbEMsQ0FBQztJQUVEOzs7Ozs7Ozs7OztPQVdHO0lBQ0gsa0JBQWtCLENBQUUsTUFBbUI7UUFDckMsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBaUMsR0FBRyxJQUFJLENBQUMsR0FBRyxvQkFBb0IsRUFBRSxFQUFFLE1BQU0sRUFBRSxDQUFDO2FBQzlGLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFBO0lBQ2xDLENBQUM7d0dBakVVLGVBQWUsa0JBRWhCLEtBQUs7NEdBRkosZUFBZSxjQUZkLE1BQU07OzRGQUVQLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25COzswQkFHSSxNQUFNOzJCQUFDLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3QsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xyXG5pbXBvcnQgeyBFbnZpcm9ubWVudCB9IGZyb20gJy4uL25neC1zZXJ2aWNlcy5tb2RlbHMnXHJcbmltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCdcclxuaW1wb3J0IHsgQXBpU3VjY2VzcywgUXVlcnlQYXJhbXMgfSBmcm9tICcuL21vZGVscy9hcGkubW9kZWxzJ1xyXG5pbXBvcnQgeyBtYXAsIE9ic2VydmFibGUgfSBmcm9tICdyeGpzJ1xyXG5pbXBvcnQgeyBRdW90ZUV2ZW50SW4sIFF1b3RlRXZlbnRPdXQsIFF1b3RlRXZlbnRzT3V0LCBRdW90ZUV2ZW50VHlwZXNPdXQgfSBmcm9tICcuL21vZGVscy9hcGktcXVvdGUudHlwZXMnXHJcblxyXG4vKipcclxuICogU2VydmljZSB0byBtYW5hZ2UgcXVvdGUtcmVsYXRlZCBldmVudHMuXHJcbiAqXHJcbiAqIFRoaXMgc2VydmljZSBwcm92aWRlcyBtZXRob2RzIHRvIHJldHJpZXZlLCBjcmVhdGUsIGFuZCBnZXQgZXZlbnQgdHlwZXNcclxuICogcmVsYXRlZCB0byBxdW90ZSBwcm9jZXNzZXMuXHJcbiAqL1xyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBBcGlRdW90ZVNlcnZpY2Uge1xyXG4gIGNvbnN0cnVjdG9yIChcclxuICAgIEBJbmplY3QoJ2VudicpIHByaXZhdGUgZW52aXJvbm1lbnRzOiBFbnZpcm9ubWVudCxcclxuICAgIHByaXZhdGUgaHR0cDogSHR0cENsaWVudFxyXG4gICkgeyB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEJhc2UgVVJMIGZvciB0aGUgUXVvdGVzIEFQSS5cclxuICAgKi9cclxuICBnZXQgdXJsICgpOiBzdHJpbmcge1xyXG4gICAgcmV0dXJuIHRoaXMuZW52aXJvbm1lbnRzLmFwaVF1b3Rlc1VybCA/PyAnJ1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogUmV0cmlldmVzIGFsbCByZWdpc3RlcmVkIGV2ZW50cyBmb3IgYSBzcGVjaWZpYyBxdW90ZS5cclxuICAgKlxyXG4gICAqIEBwYXJhbSBpZCAtIFF1b3RlIGlkZW50aWZpZXIuXHJcbiAgICogQHBhcmFtIHBhcmFtcyAtIE9wdGlvbmFsIHF1ZXJ5IHBhcmFtZXRlcnMgc3VjaCBhcyBwYWdpbmF0aW9uIG9yIGZpbHRlcmluZy5cclxuICAgKiBAcmV0dXJucyBPYnNlcnZhYmxlIGNvbnRhaW5pbmcgdGhlIGxpc3Qgb2YgcXVvdGUgZXZlbnRzLlxyXG4gICAqXHJcbiAgICogQGV4YW1wbGVcclxuICAgKiBgYGB0c1xyXG4gICAqIHRoaXMuYXBpUXVvdGVTZXJ2aWNlLmdldFF1b3RlRXZlbnRzKDEwLCB7IHBhZ2U6IDEgfSlcclxuICAgKiAgIC5zdWJzY3JpYmUoKGV2ZW50cykgPT4gY29uc29sZS5sb2coZXZlbnRzKSlcclxuICAgKiBgYGBcclxuICAgKi9cclxuICBnZXRRdW90ZUV2ZW50cyAoaWQ6IG51bWJlciwgcGFyYW1zOiBRdWVyeVBhcmFtcyk6IE9ic2VydmFibGU8UXVvdGVFdmVudHNPdXQ+IHtcclxuICAgIHJldHVybiB0aGlzLmh0dHAuZ2V0PEFwaVN1Y2Nlc3M8UXVvdGVFdmVudHNPdXQ+PihgJHt0aGlzLnVybH0vcXVvdGVzLyR7aWR9L3F1b3RlLWV2ZW50c2AsIHsgcGFyYW1zIH0pXHJcbiAgICAgIC5waXBlKG1hcCgoeyBkYXRhIH0pID0+IGRhdGEpKVxyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogUmVnaXN0ZXJzIGEgbmV3IGV2ZW50IHJlbGF0ZWQgdG8gYSBzcGVjaWZpYyBxdW90ZS5cclxuICAgKlxyXG4gICAqIEBwYXJhbSBpZCAtIFF1b3RlIGlkZW50aWZpZXIuXHJcbiAgICogQHBhcmFtIGJvZHkgLSBFdmVudCBwYXlsb2FkIHRvIGJlIGNyZWF0ZWQuXHJcbiAgICogQHJldHVybnMgT2JzZXJ2YWJsZSBjb250YWluaW5nIHRoZSBuZXdseSBjcmVhdGVkIGV2ZW50LlxyXG4gICAqXHJcbiAgICogQGV4YW1wbGVcclxuICAgKiBgYGB0c1xyXG4gICAqIGNvbnN0IGV2ZW50OiBRdW90ZUV2ZW50SW4gPSB7IGNvZGU6ICdXT04nLCBub3RlOiAnQ2xpZW50IGFwcHJvdmVkJyB9XHJcbiAgICogdGhpcy5hcGlRdW90ZVNlcnZpY2UucG9zdFF1b3RlRXZlbnRzKDEwLCBldmVudClcclxuICAgKiAgIC5zdWJzY3JpYmUoKHJlc3BvbnNlKSA9PiBjb25zb2xlLmxvZyhyZXNwb25zZSkpXHJcbiAgICogYGBgXHJcbiAgICovXHJcbiAgcG9zdFF1b3RlRXZlbnRzIChpZDogbnVtYmVyLCBib2R5OiBRdW90ZUV2ZW50SW4pOiBPYnNlcnZhYmxlPFF1b3RlRXZlbnRPdXQ+IHtcclxuICAgIHJldHVybiB0aGlzLmh0dHAucG9zdDxBcGlTdWNjZXNzPFF1b3RlRXZlbnRPdXQ+PihgJHt0aGlzLnVybH0vcXVvdGVzLyR7aWR9L3F1b3RlLWV2ZW50c2AsIGJvZHkpXHJcbiAgICAgIC5waXBlKG1hcCgoeyBkYXRhIH0pID0+IGRhdGEpKVxyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogUmV0cmlldmVzIHRoZSBhdmFpbGFibGUgcXVvdGUgZXZlbnQgdHlwZXMuXHJcbiAgICpcclxuICAgKiBAcGFyYW0gcGFyYW1zIC0gT3B0aW9uYWwgcXVlcnkgcGFyYW1ldGVycyBzdWNoIGFzIHBhZ2luYXRpb24gb3IgZmlsdGVyaW5nLlxyXG4gICAqIEByZXR1cm5zIE9ic2VydmFibGUgY29udGFpbmluZyB0aGUgbGlzdCBvZiBldmVudCB0eXBlcy5cclxuICAgKlxyXG4gICAqIEBleGFtcGxlXHJcbiAgICogYGBgdHNcclxuICAgKiB0aGlzLmFwaVF1b3RlU2VydmljZS5nZXRRdW90ZUV2ZW50VHlwZXMoeyBwYWdlOiAxIH0pXHJcbiAgICogICAuc3Vic2NyaWJlKCh0eXBlcykgPT4gY29uc29sZS5sb2codHlwZXMpKVxyXG4gICAqIGBgYFxyXG4gICAqL1xyXG4gIGdldFF1b3RlRXZlbnRUeXBlcyAocGFyYW1zOiBRdWVyeVBhcmFtcyk6IE9ic2VydmFibGU8UXVvdGVFdmVudFR5cGVzT3V0PiB7XHJcbiAgICByZXR1cm4gdGhpcy5odHRwLmdldDxBcGlTdWNjZXNzPFF1b3RlRXZlbnRUeXBlc091dD4+KGAke3RoaXMudXJsfS9xdW90ZS1ldmVudC10eXBlc2AsIHsgcGFyYW1zIH0pXHJcbiAgICAgIC5waXBlKG1hcCgoeyBkYXRhIH0pID0+IGRhdGEpKVxyXG4gIH1cclxufVxyXG4iXX0=

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-companies.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { ActiveLessLaravelModel, LaravelModel } from './api.models'\r\nimport { BoardingProcessStatus, Country, Currency, IdentificationType, Product, State } from './api-catalog.interfaces'\r\n\r\nexport interface Account extends LaravelModel {\r\n  number: string\r\n  description: string | null\r\n  account_type_id: number\r\n  account_type: AccountType\r\n  country_id: number\r\n  domestic_approved: boolean\r\n  is_default: boolean\r\n}\r\n\r\nexport interface AccountCategory extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface AccountType extends LaravelModel {\r\n  name: string\r\n  account_category_id: number\r\n  account_category?: AccountCategory\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: 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  country: Country\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 CountryReferenceExtraCharge extends LaravelModel {\r\n  country_id: number\r\n  extra_charge_id: number\r\n  local_availability: boolean\r\n  mandatory: boolean\r\n  selected: boolean\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  value_local: number\r\n  value_usd: number\r\n}\r\n\r\nexport interface ExtraChargeEntity extends LaravelModel {\r\n  code: string\r\n  name: string\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  email: string\r\n  username: 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  locations: Location[]\r\n  company: Company\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: string\r\n  type: string\r\n}\r\n\r\nexport interface CountryExchange extends Exchange {\r\n  currency: Currency\r\n  country_reference_currency: CountryReferenceCurrency\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  number: number\r\n  system: System\r\n  customer_screen: boolean\r\n  epod_capture: boolean\r\n  cx_survey: boolean\r\n  customer_flow: boolean\r\n  promotional_content: boolean\r\n}\r\n\r\nexport interface Location extends LaravelModel {\r\n  accounts: Account[]\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  billing_code: string | null\r\n  city_name: string\r\n  commission_account: string | null\r\n  company_country: CompanyCountry\r\n  company_country_id: number\r\n  contact_name: string | null\r\n  country_region: null\r\n  country_region_id: number | null\r\n  country_zone: null\r\n  country_zone_id: number | null\r\n  county_name: string\r\n  default_account_id: number | null\r\n  email: string | null\r\n  etools_auto_billing_enabled: boolean\r\n  extra_fields: { [key: string]: string | number | boolean | null }\r\n  facility_code: string\r\n  facility_id: number\r\n  gmt_offset: string\r\n  google_maps_id: string\r\n  iata_code: string\r\n  is_occurs: boolean\r\n  location_code: string | null\r\n  locker_enabled: boolean\r\n  management_area: null\r\n  management_area_id: number | null\r\n  name: string\r\n  phone_code: string\r\n  phone_number: string\r\n  queue_manager_enabled: boolean\r\n  route_number: string\r\n  service_area_code: string\r\n  service_point_id: string\r\n  state: State\r\n  state_code: string | null\r\n  state_id: number\r\n  state_name: string\r\n  supervisor: Employee\r\n  type: string\r\n  zip_code: string\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 extends LaravelModel {\r\n  name: string\r\n  type: string\r\n  regex: string\r\n  description: string\r\n  value: string | number | boolean | null | { [key: string]: (string | number | boolean | null)[] }\r\n  parameter_type_id: number\r\n}\r\n\r\nexport interface ParameterConfig {\r\n  id: number\r\n  level: number\r\n  model_type: string | null\r\n  model_id: number | null\r\n  parameter_id: number\r\n  name: string\r\n  value: string | number | boolean | null | { [key: string]: (string | number | boolean | null)[] }\r\n  parameter: Parameter\r\n}\r\n\r\nexport interface WorkflowConfig {\r\n  id: number\r\n  system_id: number\r\n  level: string\r\n  model_type: string\r\n  model_id: number\r\n  name: string\r\n  page_id: number\r\n  page_name: string\r\n  enabled: boolean\r\n}\r\n\r\nexport interface EmployeeCustomerDhl extends LaravelModel {\r\n  identification_type_id: number\r\n  identification_type_value: string\r\n  name: string\r\n  last_name: string\r\n  address: string\r\n  phone_code: string\r\n  phone_number: string\r\n  email: string\r\n  country_id: number\r\n  employee_id: number | null\r\n  identification_type: IdentificationType\r\n}\r\n\r\nexport interface BoardingProcess {\r\n  id: number\r\n  boarding_process_type_id: number\r\n  status_id: number\r\n  is_finished: boolean\r\n  start_date_time: string\r\n  end_date_time: string\r\n  created_at: string\r\n  updated_at: string\r\n  status: BoardingProcessStatus\r\n  boarding_process_histories: BoardingProcessHistory[]\r\n}\r\n\r\nexport interface BoardingProcessHistory {\r\n  id: number\r\n  boarding_process_id: number\r\n  status_id: number\r\n  messages: string[]\r\n  created_at: string\r\n  updated_at: string\r\n}\r\n\r\nexport interface System extends LaravelModel {\r\n  name: string\r\n  type: string\r\n  configuration: { [key: string]: string }\r\n  can_workflow_config: boolean\r\n}\r\n\r\nexport interface CountryReferenceProduct extends LaravelModel {\r\n  country_id: number\r\n  product_id: number\r\n  local_name: string\r\n  min_weight: number\r\n  max_weight: number\r\n  insurance: number\r\n  business_letter: boolean\r\n  packaging: boolean\r\n  anti_drug_letter: boolean\r\n  max_declared_value: number\r\n  shipment_groups: number[]\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  is_prepaid_dropoff: boolean\r\n  product: Product\r\n}\r\n\r\nexport interface ProductEntity extends LaravelModel {\r\n  global_code: string\r\n  local_code: string\r\n  global_name: string\r\n  local_name: string\r\n}\r\n\r\nexport interface TDXAccountSetting extends LaravelModel {\r\n  location_id: number\r\n  account_id: number\r\n  product_id: number\r\n  product_global_code_name: string\r\n  product_local_code_name: string\r\n  account: AccountToTDX\r\n}\r\n\r\nexport interface AccountToTDX extends ActiveLessLaravelModel {\r\n  number: string\r\n  description: string | null\r\n  account_type_id: number\r\n  country_id: number\r\n}\r\n\r\nexport interface SupplyEntity extends LaravelModel {\r\n  name: string\r\n  description: null | string\r\n  country_id: number\r\n  enabled_for_dropoff: boolean\r\n  supply_type: SupplyEntityType\r\n  supply_packing: SupplyEntityPacking\r\n}\r\n\r\nexport interface SupplyEntityType extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface SupplyEntityPacking {\r\n  value: number\r\n  weight: number\r\n  height: number\r\n  depth: number\r\n  width: number\r\n  emobile_code: null | string\r\n  created_at: string\r\n  updated_at: string\r\n}\r\n\r\nexport interface ExtraChargeEntityConfigGlobal extends LaravelModel {\r\n  extracharge_id: number\r\n  entity_id: number\r\n  entity: EntityExtraCharge\r\n}\r\n\r\nexport interface EntityExtraCharge extends LaravelModel {\r\n  level: string\r\n  model_type: string\r\n  model_id: string,\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-companies.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { ActiveLessLaravelModel, LaravelModel } from './api.models'\r\nimport { BoardingProcessStatus, Country, Currency, IdentificationType, Product, State } from './api-catalog.interfaces'\r\n\r\nexport interface Account extends LaravelModel {\r\n  number: string\r\n  description: string | null\r\n  account_type_id: number\r\n  account_type: AccountType\r\n  country_id: number\r\n  domestic_approved: boolean\r\n  is_default: boolean\r\n}\r\n\r\nexport interface AccountCategory extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface AccountType extends LaravelModel {\r\n  name: string\r\n  account_category_id: number\r\n  account_category?: AccountCategory\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: 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  country: Country\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 CountryReferenceExtraCharge extends LaravelModel {\r\n  country_id: number\r\n  extra_charge_id: number\r\n  local_availability: boolean\r\n  mandatory: boolean\r\n  selected: boolean\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  value_local: number\r\n  value_usd: number\r\n}\r\n\r\nexport interface ExtraChargeEntity extends LaravelModel {\r\n  code: string\r\n  name: string\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  email: string\r\n  username: 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  locations: Location[]\r\n  company: Company\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: string\r\n  type: string\r\n}\r\n\r\nexport interface CountryExchange extends Exchange {\r\n  currency: Currency\r\n  country_reference_currency: CountryReferenceCurrency\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  number: number\r\n  system: System\r\n  customer_screen: boolean\r\n  epod_capture: boolean\r\n  cx_survey: boolean\r\n  customer_flow: boolean\r\n  promotional_content: boolean\r\n}\r\n\r\nexport interface Location extends LaravelModel {\r\n  accounts: Account[]\r\n  address1: string\r\n  address2: string\r\n  address3: string\r\n  billing_code: string | null\r\n  city_name: string\r\n  commission_account: string | null\r\n  company_country: CompanyCountry\r\n  company_country_id: number\r\n  contact_name: string | null\r\n  country_region: null\r\n  country_region_id: number | null\r\n  country_zone: null\r\n  country_zone_id: number | null\r\n  county_name: string\r\n  default_account_id: number | null\r\n  email: string | null\r\n  etools_auto_billing_enabled: boolean\r\n  extra_fields: { [key: string]: string | number | boolean | null }\r\n  facility_code: string\r\n  facility_id: number\r\n  gmt_offset: string\r\n  google_maps_id: string\r\n  iata_code: string\r\n  is_occurs: boolean\r\n  location_code: string | null\r\n  locker_enabled: boolean\r\n  management_area: null\r\n  management_area_id: number | null\r\n  name: string\r\n  phone_code: string\r\n  phone_number: string\r\n  queue_manager_enabled: boolean\r\n  route_number: string\r\n  service_area_code: string\r\n  service_point_id: string\r\n  state: State\r\n  state_code: string | null\r\n  state_id: number\r\n  state_name: string\r\n  supervisor: Employee\r\n  type: string\r\n  zip_code: string\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 extends LaravelModel {\r\n  name: string\r\n  type: string\r\n  regex: string\r\n  description: string\r\n  value: string | number | boolean | null | { [key: string]: (string | number | boolean | null)[] }\r\n  parameter_type_id: number\r\n}\r\n\r\nexport interface ParameterConfig {\r\n  id: number\r\n  level: number\r\n  model_type: string | null\r\n  model_id: number | null\r\n  parameter_id: number\r\n  name: string\r\n  value: string | number | boolean | null | { [key: string]: (string | number | boolean | null)[] }\r\n  parameter: Parameter\r\n}\r\n\r\nexport interface WorkflowConfig {\r\n  id: number\r\n  system_id: number\r\n  level: string\r\n  model_type: string\r\n  model_id: number\r\n  name: string\r\n  page_id: number\r\n  page_name: string\r\n  enabled: boolean\r\n}\r\n\r\nexport interface EmployeeCustomerDhl extends LaravelModel {\r\n  identification_type_id: number\r\n  identification_type_value: string\r\n  name: string\r\n  last_name: string\r\n  address: string\r\n  phone_code: string\r\n  phone_number: string\r\n  email: string\r\n  country_id: number\r\n  employee_id: number | null\r\n  identification_type: IdentificationType\r\n}\r\n\r\nexport interface BoardingProcess {\r\n  id: number\r\n  boarding_process_type_id: number\r\n  status_id: number\r\n  is_finished: boolean\r\n  start_date_time: string\r\n  end_date_time: string\r\n  created_at: string\r\n  updated_at: string\r\n  status: BoardingProcessStatus\r\n  boarding_process_histories: BoardingProcessHistory[]\r\n}\r\n\r\nexport interface BoardingProcessHistory {\r\n  id: number\r\n  boarding_process_id: number\r\n  status_id: number\r\n  messages: string[]\r\n  created_at: string\r\n  updated_at: string\r\n}\r\n\r\nexport interface System extends LaravelModel {\r\n  name: string\r\n  type: string\r\n  configuration: { [key: string]: string }\r\n  can_workflow_config: boolean\r\n}\r\n\r\nexport interface CountryReferenceProduct extends LaravelModel {\r\n  country_id: number\r\n  product_id: number\r\n  local_name: string\r\n  min_weight: number\r\n  max_weight: number\r\n  insurance: number\r\n  business_letter: boolean\r\n  packaging: boolean\r\n  anti_drug_letter: boolean\r\n  max_declared_value: number\r\n  shipment_groups: number[]\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  is_prepaid_dropoff: boolean\r\n  product: Product\r\n}\r\n\r\nexport interface ProductEntity extends LaravelModel {\r\n  global_code: string\r\n  local_code: string\r\n  global_name: string\r\n  local_name: string\r\n}\r\n\r\nexport interface TDXAccountSetting extends LaravelModel {\r\n  location_id: number\r\n  account_id: number\r\n  product_id: number\r\n  product_global_code_name: string\r\n  product_local_code_name: string\r\n  account: AccountToTDX\r\n}\r\n\r\nexport interface AccountToTDX extends ActiveLessLaravelModel {\r\n  number: string\r\n  description: string | null\r\n  account_type_id: number\r\n  country_id: number\r\n}\r\n\r\nexport interface SupplyEntity extends LaravelModel {\r\n  name: string\r\n  description: null | string\r\n  country_id: number\r\n  enabled_for_dropoff: boolean\r\n  supply_type: SupplyEntityType\r\n  supply_packing: SupplyEntityPacking\r\n}\r\n\r\nexport interface SupplyEntityType extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface SupplyEntityPacking {\r\n  value: number\r\n  weight: number\r\n  height: number\r\n  depth: number\r\n  width: number\r\n  emobile_code: null | string\r\n  created_at: string\r\n  updated_at: string\r\n}\r\n"]}

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.types.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-companies.types.ts"],"names":[],"mappings":"","sourcesContent":["import {\r\n  Account,\r\n  AccountCategory,\r\n  AccountType,\r\n  BoardingProcess,\r\n  Company,\r\n  CompanyCountry,\r\n  CompanyCountryTax,\r\n  CountryExchange,\r\n  CountryReference,\r\n  CountryReferenceCurrency,\r\n  CountryReferenceExtraCharge,\r\n  CountryReferenceProduct,\r\n  Employee,\r\n  EmployeeCustomerDhl,\r\n  ExtraChargeEntity,\r\n  ExtraChargeEntityConfigGlobal,\r\n  Installation,\r\n  Location,\r\n  LocationEmployee,\r\n  Parameter,\r\n  ParameterConfig,\r\n  ProductEntity,\r\n  SupplyEntity,\r\n  System,\r\n  TDXAccountSetting,\r\n  WorkflowConfig\r\n} from './api-companies.interfaces'\r\nimport { QueryParams } from './api.models'\r\n\r\nexport type LocationEmployeesOut = {\r\n  location_employees: LocationEmployee[]\r\n  total: number\r\n}\r\n\r\nexport type LocationEmployeeBatchIn = {\r\n  store_update: {\r\n    location_id: number\r\n    employee_id: number\r\n    is_active: boolean\r\n  }[];\r\n}\r\n\r\nexport type LocationEmployeeOut = {\r\n  location_employee: LocationEmployee\r\n}\r\n\r\nexport type InstallationsOut = {\r\n  installations: Installation[]\r\n  total: number\r\n}\r\n\r\nexport type InstallationIn = {\r\n  system_id: number\r\n  mac_address: string\r\n  ip_address: string\r\n  location_id: number\r\n  number: number\r\n  customer_screen: boolean\r\n  epod_capture: boolean\r\n  cx_survey: boolean\r\n  customer_flow: boolean\r\n  promotional_content: boolean\r\n}\r\n\r\nexport type InstallationOut = {\r\n  installation: Installation\r\n}\r\n\r\nexport type LocationsOut = {\r\n  locations: Location[]\r\n  total: number\r\n}\r\n\r\nexport type LocationIn = {\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  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_number: string\r\n  phone_code: string\r\n  is_active: boolean\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  route_number: string\r\n  locker_enabled: boolean\r\n  queue_manager_enabled: boolean\r\n  commission_account: string\r\n  type: string\r\n  facility_id: number\r\n  service_point_id: number\r\n  default_account_id: number\r\n  extra_fields: { [key: string]: string | number | boolean | null }\r\n}\r\nexport type LocationOut = {\r\n  location: Location\r\n}\r\n\r\nexport type SupplyEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  check_all?: boolean\r\n  supply_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type SupplyEntitiesOut = {\r\n  supply_entities: SupplyEntity[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeesOut = {\r\n  employees: Employee[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeeIn = {\r\n  auth_type: string\r\n  company_id: number\r\n  country_id: number\r\n  email: string\r\n  last_name: string\r\n  name: string\r\n  username: string\r\n  number: string\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}\r\nexport type EmployeeOut = {\r\n  employee: Employee\r\n}\r\n\r\nexport type CompanyCountriesOut = {\r\n  company_countries: CompanyCountry[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyCountryIn = {\r\n  company_id: number\r\n  country_id: number\r\n  is_active: boolean\r\n  headquarters_city_code: string | null\r\n  lp_code: string | null\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 | null\r\n  city: string | null\r\n  zip_code: string | null\r\n  county_name: string | null\r\n  address1: string\r\n  address2: string | null\r\n  address3: string | null\r\n}\r\nexport type CompanyCountryOut = {\r\n  company_country: CompanyCountry\r\n}\r\n\r\nexport type CountryReferenceCurrencyIn = {\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  is_active: boolean\r\n}\r\nexport type CountryReferenceCurrencyOut = {\r\n  country_reference_currency: CountryReferenceCurrency\r\n}\r\n\r\nexport type CountryReferenceCurrenciesOut = {\r\n  country_reference_currencies: CountryReferenceCurrency[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyCountryTaxesOut = {\r\n  company_country_taxes: CompanyCountryTax[]\r\n  total: number\r\n}\r\n\r\nexport type ExchangeIn = {\r\n  country_reference_currency_id: number\r\n  valid_since: string\r\n  valid_until?: string\r\n  value: string\r\n  type: string\r\n  is_active: boolean\r\n}\r\n\r\nexport type ExchangesOut = {\r\n  exchanges: CountryExchange[]\r\n  total: number\r\n}\r\n\r\nexport type ExchangeOut = {\r\n  exchange: CountryExchange\r\n}\r\n\r\nexport type AccountsOut = {\r\n  accounts: Account[]\r\n  total: number\r\n}\r\n\r\nexport type AccountIn = {\r\n  number: string\r\n  description: string\r\n  account_type_id: number\r\n  country_id: number\r\n}\r\nexport type AccountOut = {\r\n  account: Account\r\n}\r\n\r\nexport type AccountEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  account_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type AccountEntitiesOut = {\r\n  account_entities: Account[]\r\n  total: number\r\n}\r\n\r\nexport type AccountCategoriesOut = {\r\n  account_categories: AccountCategory[]\r\n  total: number\r\n}\r\n\r\nexport type AccountTypeIn = {\r\n  name: string\r\n  account_category_id: number\r\n}\r\nexport type AccountTypeOut = {\r\n  account_type: AccountType\r\n}\r\n\r\nexport type AccountTypesOut = {\r\n  account_types: AccountType[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersOut = {\r\n  parameters: Parameter[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersValuesIn = {\r\n  paramNames: string[]\r\n}\r\nexport type ParametersValuesOut = {\r\n  parameters: Parameter[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersByLevelIn = {\r\n  name: string\r\n  model_type: string\r\n  model_id: number\r\n}[]\r\n\r\nexport type ParameterValueIn = {\r\n  paramName: string\r\n}\r\nexport type ParameterValueOut = {\r\n  value: string | boolean | number | { [key: string]: (string | boolean | number)[] }\r\n}\r\n\r\nexport type CountryReferencesOut = {\r\n  country_references: CountryReference[]\r\n}\r\n\r\nexport type CountryReferenceIn = {\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  currency_id: number\r\n  is_active: boolean\r\n  locale: string\r\n  language_id: number\r\n  restricted_import_countries: 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}\r\nexport type CountryReferenceOut = {\r\n  country_reference: CountryReference\r\n}\r\n\r\nexport type CountryReferenceExtraChargeIn = {\r\n  local_availability: boolean\r\n  mandatory: boolean\r\n  selected: boolean\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  value_local: number\r\n  value_usd: number\r\n  country_id: number\r\n  extra_charge_id: number\r\n}\r\n\r\nexport type CountryReferenceExtraChargeOut = {\r\n  country_reference_extra_charge: CountryReferenceExtraCharge\r\n}\r\n\r\nexport type WorkflowsOut = {\r\n  workflow: {\r\n    page: string\r\n    enabled: boolean\r\n  }[]\r\n  system_configuration: object\r\n}\r\n\r\nexport type EmployeesCustomersOut = {\r\n  employee_customers: EmployeeCustomerDhl[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeeCustomersOut = {\r\n  employee_customer: EmployeeCustomerDhl\r\n}\r\n\r\nexport type EmployeeCustomersIn = {\r\n  identification_type_id: number\r\n  identification_type_value: string\r\n  name: string\r\n  last_name: string\r\n  address: string\r\n  phone_code: string\r\n  phone_number: string\r\n  email: string\r\n  country_id: number\r\n  employee_id: number | null\r\n  is_active: boolean\r\n}\r\n\r\nexport type BoardingProcessIn = {\r\n  boarding_process: BoardingProcess;\r\n}\r\n\r\nexport type BoardingProcessIdIn = {\r\n  boarding_process_id: number\r\n  message: string\r\n}\r\n\r\nexport type SystemsOut = {\r\n  systems: System[]\r\n  total: number\r\n}\r\n\r\nexport type SystemIn = {\r\n  name: string\r\n  type: string\r\n  can_workflow_config?: boolean\r\n  configuration: { [key: string]: string }\r\n}\r\nexport type SystemOut = {\r\n  system: System\r\n}\r\n\r\nexport type SystemEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  system_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\nexport type SystemEntitiesOut = {\r\n  system_entities: System[]\r\n  total: number\r\n}\r\n\r\nexport type WorkflowConfigsBatchIn = {\r\n  store: {\r\n    system_id: number\r\n    model_type: string\r\n    model_id: number\r\n    page_id: number\r\n    enabled: boolean\r\n  }[]\r\n  update: {\r\n    system_id: number\r\n    model_type: string\r\n    model_id: number\r\n    page_id: number\r\n    enabled: boolean\r\n  }[]\r\n}\r\n\r\nexport type WorkflowConfigsOut = {\r\n  workflow_configs: WorkflowConfig[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyIn = {\r\n  name: string\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 | null\r\n  city: string | null\r\n  county_name: string | null\r\n  zip_code: string | null\r\n  address1: string\r\n  address2: string | null\r\n  address3: string | null\r\n  is_active: boolean\r\n}\r\nexport type CompanyOut = {\r\n  company: Company\r\n}\r\n\r\nexport type ProductEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  product_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type ProductEntitiesOut = {\r\n  product_entities: ProductEntity[]\r\n  total: number\r\n}\r\n\r\nexport type CountryReferenceProductsOut = {\r\n  country_reference_products: CountryReferenceProduct[]\r\n  total: number\r\n}\r\n\r\nexport type CountryReferenceProductIn = {\r\n  anti_drug_letter: boolean\r\n  business_letter: boolean\r\n  country_id: number\r\n  max_declared_value: number\r\n  max_weight: number\r\n  min_weight: number\r\n  packaging: boolean\r\n  product_id: number\r\n  shipment_content_types: number[]\r\n  shipment_groups: number[]\r\n  shipment_scopes: number[]\r\n  local_name: string\r\n  insurance: number\r\n}\r\nexport type CountryReferenceProductOut = {\r\n  country_reference_product: CountryReferenceProduct\r\n}\r\n\r\nexport type ExtraChargeEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  extracharge_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\nexport type ExtraChargeEntitiesOut = {\r\n  extracharge_entities: ExtraChargeEntity[]\r\n  total: number\r\n}\r\n\r\nexport type ParameterConfigsOut = {\r\n  parameter_configs: ParameterConfig[]\r\n  total: number\r\n}\r\n\r\nexport type ParameterConfigIn = {\r\n  level: string\r\n  parameter_id: number\r\n  model_type: string\r\n  model_id: number\r\n  name: string\r\n  value: string\r\n}\r\nexport type ParameterConfigOut = {\r\n  parameter_config: ParameterConfig\r\n  total: number\r\n}\r\n\r\nexport type TDXAccountsSettingsOut = {\r\n  tdx_account_settings: TDXAccountSetting[]\r\n  total: number\r\n}\r\n\r\nexport type TDXAccountSettingsOut = {\r\n  tdx_account_settings: TDXAccountSetting\r\n}\r\n\r\nexport type TDXAccountSettingsIn = {\r\n  id?: number\r\n  location_id: number\r\n  account_id: number\r\n  product_id: number\r\n  is_active: boolean\r\n}\r\n\r\nexport type LocationEmployeesIn = { token: string } & QueryParams\r\n\r\nexport type ExtraChargeEntityGlobalConfigIn = {\r\n  extracharge_id: number\r\n  is_active?: boolean\r\n}\r\n\r\nexport type ExtraChargeEntityGlobalConfigOut = {\r\n  extracharge_entities: ExtraChargeEntityConfigGlobal\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.types.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-companies.types.ts"],"names":[],"mappings":"","sourcesContent":["import {\r\n  Account,\r\n  AccountCategory,\r\n  AccountType,\r\n  BoardingProcess,\r\n  Company,\r\n  CompanyCountry,\r\n  CompanyCountryTax,\r\n  CountryExchange,\r\n  CountryReference,\r\n  CountryReferenceCurrency,\r\n  CountryReferenceExtraCharge,\r\n  CountryReferenceProduct,\r\n  Employee,\r\n  EmployeeCustomerDhl,\r\n  ExtraChargeEntity,\r\n  Installation,\r\n  Location,\r\n  LocationEmployee,\r\n  Parameter,\r\n  ParameterConfig,\r\n  ProductEntity,\r\n  SupplyEntity,\r\n  System,\r\n  TDXAccountSetting,\r\n  WorkflowConfig\r\n} from './api-companies.interfaces'\r\nimport { QueryParams } from './api.models'\r\n\r\nexport type LocationEmployeesOut = {\r\n  location_employees: LocationEmployee[]\r\n  total: number\r\n}\r\n\r\nexport type LocationEmployeeBatchIn = {\r\n  store_update: {\r\n    location_id: number\r\n    employee_id: number\r\n    is_active: boolean\r\n  }[];\r\n}\r\n\r\nexport type LocationEmployeeOut = {\r\n  location_employee: LocationEmployee\r\n}\r\n\r\nexport type InstallationsOut = {\r\n  installations: Installation[]\r\n  total: number\r\n}\r\n\r\nexport type InstallationIn = {\r\n  system_id: number\r\n  mac_address: string\r\n  ip_address: string\r\n  location_id: number\r\n  number: number\r\n  customer_screen: boolean\r\n  epod_capture: boolean\r\n  cx_survey: boolean\r\n  customer_flow: boolean\r\n  promotional_content: boolean\r\n}\r\n\r\nexport type InstallationOut = {\r\n  installation: Installation\r\n}\r\n\r\nexport type LocationsOut = {\r\n  locations: Location[]\r\n  total: number\r\n}\r\n\r\nexport type LocationIn = {\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  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_number: string\r\n  phone_code: string\r\n  is_active: boolean\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  route_number: string\r\n  locker_enabled: boolean\r\n  queue_manager_enabled: boolean\r\n  commission_account: string\r\n  type: string\r\n  facility_id: number\r\n  service_point_id: number\r\n  default_account_id: number\r\n  extra_fields: { [key: string]: string | number | boolean | null }\r\n}\r\nexport type LocationOut = {\r\n  location: Location\r\n}\r\n\r\nexport type SupplyEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  check_all?: boolean\r\n  supply_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type SupplyEntitiesOut = {\r\n  supply_entities: SupplyEntity[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeesOut = {\r\n  employees: Employee[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeeIn = {\r\n  auth_type: string\r\n  company_id: number\r\n  country_id: number\r\n  email: string\r\n  last_name: string\r\n  name: string\r\n  username: string\r\n  number: string\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}\r\nexport type EmployeeOut = {\r\n  employee: Employee\r\n}\r\n\r\nexport type CompanyCountriesOut = {\r\n  company_countries: CompanyCountry[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyCountryIn = {\r\n  company_id: number\r\n  country_id: number\r\n  is_active: boolean\r\n  headquarters_city_code: string | null\r\n  lp_code: string | null\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 | null\r\n  city: string | null\r\n  zip_code: string | null\r\n  county_name: string | null\r\n  address1: string\r\n  address2: string | null\r\n  address3: string | null\r\n}\r\nexport type CompanyCountryOut = {\r\n  company_country: CompanyCountry\r\n}\r\n\r\nexport type CountryReferenceCurrencyIn = {\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  is_active: boolean\r\n}\r\nexport type CountryReferenceCurrencyOut = {\r\n  country_reference_currency: CountryReferenceCurrency\r\n}\r\n\r\nexport type CountryReferenceCurrenciesOut = {\r\n  country_reference_currencies: CountryReferenceCurrency[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyCountryTaxesOut = {\r\n  company_country_taxes: CompanyCountryTax[]\r\n  total: number\r\n}\r\n\r\nexport type ExchangeIn = {\r\n  country_reference_currency_id: number\r\n  valid_since: string\r\n  valid_until?: string\r\n  value: string\r\n  type: string\r\n  is_active: boolean\r\n}\r\n\r\nexport type ExchangesOut = {\r\n  exchanges: CountryExchange[]\r\n  total: number\r\n}\r\n\r\nexport type ExchangeOut = {\r\n  exchange: CountryExchange\r\n}\r\n\r\nexport type AccountsOut = {\r\n  accounts: Account[]\r\n  total: number\r\n}\r\n\r\nexport type AccountIn = {\r\n  number: string\r\n  description: string\r\n  account_type_id: number\r\n  country_id: number\r\n}\r\nexport type AccountOut = {\r\n  account: Account\r\n}\r\n\r\nexport type AccountEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  account_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type AccountEntitiesOut = {\r\n  account_entities: Account[]\r\n  total: number\r\n}\r\n\r\nexport type AccountCategoriesOut = {\r\n  account_categories: AccountCategory[]\r\n  total: number\r\n}\r\n\r\nexport type AccountTypeIn = {\r\n  name: string\r\n  account_category_id: number\r\n}\r\nexport type AccountTypeOut = {\r\n  account_type: AccountType\r\n}\r\n\r\nexport type AccountTypesOut = {\r\n  account_types: AccountType[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersOut = {\r\n  parameters: Parameter[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersValuesIn = {\r\n  paramNames: string[]\r\n}\r\nexport type ParametersValuesOut = {\r\n  parameters: Parameter[]\r\n  total: number\r\n}\r\n\r\nexport type ParametersByLevelIn = {\r\n  name: string\r\n  model_type: string\r\n  model_id: number\r\n}[]\r\n\r\nexport type ParameterValueIn = {\r\n  paramName: string\r\n}\r\nexport type ParameterValueOut = {\r\n  value: string | boolean | number | { [key: string]: (string | boolean | number)[] }\r\n}\r\n\r\nexport type CountryReferencesOut = {\r\n  country_references: CountryReference[]\r\n}\r\n\r\nexport type CountryReferenceIn = {\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  currency_id: number\r\n  is_active: boolean\r\n  locale: string\r\n  language_id: number\r\n  restricted_import_countries: 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}\r\nexport type CountryReferenceOut = {\r\n  country_reference: CountryReference\r\n}\r\n\r\nexport type CountryReferenceExtraChargeIn = {\r\n  local_availability: boolean\r\n  mandatory: boolean\r\n  selected: boolean\r\n  shipment_scopes: number[]\r\n  shipment_content_types: number[]\r\n  value_local: number\r\n  value_usd: number\r\n  country_id: number\r\n  extra_charge_id: number\r\n}\r\n\r\nexport type CountryReferenceExtraChargeOut = {\r\n  country_reference_extra_charge: CountryReferenceExtraCharge\r\n}\r\n\r\nexport type WorkflowsOut = {\r\n  workflow: {\r\n    page: string\r\n    enabled: boolean\r\n  }[]\r\n  system_configuration: object\r\n}\r\n\r\nexport type EmployeesCustomersOut = {\r\n  employee_customers: EmployeeCustomerDhl[]\r\n  total: number\r\n}\r\n\r\nexport type EmployeeCustomersOut = {\r\n  employee_customer: EmployeeCustomerDhl\r\n}\r\n\r\nexport type EmployeeCustomersIn = {\r\n  identification_type_id: number\r\n  identification_type_value: string\r\n  name: string\r\n  last_name: string\r\n  address: string\r\n  phone_code: string\r\n  phone_number: string\r\n  email: string\r\n  country_id: number\r\n  employee_id: number | null\r\n  is_active: boolean\r\n}\r\n\r\nexport type BoardingProcessIn = {\r\n  boarding_process: BoardingProcess;\r\n}\r\n\r\nexport type BoardingProcessIdIn = {\r\n  boarding_process_id: number\r\n  message: string\r\n}\r\n\r\nexport type SystemsOut = {\r\n  systems: System[]\r\n  total: number\r\n}\r\n\r\nexport type SystemIn = {\r\n  name: string\r\n  type: string\r\n  can_workflow_config?: boolean\r\n  configuration: { [key: string]: string }\r\n}\r\nexport type SystemOut = {\r\n  system: System\r\n}\r\n\r\nexport type SystemEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  system_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\nexport type SystemEntitiesOut = {\r\n  system_entities: System[]\r\n  total: number\r\n}\r\n\r\nexport type WorkflowConfigsBatchIn = {\r\n  store: {\r\n    system_id: number\r\n    model_type: string\r\n    model_id: number\r\n    page_id: number\r\n    enabled: boolean\r\n  }[]\r\n  update: {\r\n    system_id: number\r\n    model_type: string\r\n    model_id: number\r\n    page_id: number\r\n    enabled: boolean\r\n  }[]\r\n}\r\n\r\nexport type WorkflowConfigsOut = {\r\n  workflow_configs: WorkflowConfig[]\r\n  total: number\r\n}\r\n\r\nexport type CompanyIn = {\r\n  name: string\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 | null\r\n  city: string | null\r\n  county_name: string | null\r\n  zip_code: string | null\r\n  address1: string\r\n  address2: string | null\r\n  address3: string | null\r\n  is_active: boolean\r\n}\r\nexport type CompanyOut = {\r\n  company: Company\r\n}\r\n\r\nexport type ProductEntitiesIn = {\r\n  model_type: string\r\n  model_id: number\r\n  product_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[]\r\n}\r\n\r\nexport type ProductEntitiesOut = {\r\n  product_entities: ProductEntity[]\r\n  total: number\r\n}\r\n\r\nexport type CountryReferenceProductsOut = {\r\n  country_reference_products: CountryReferenceProduct[]\r\n  total: number\r\n}\r\n\r\nexport type CountryReferenceProductIn = {\r\n  anti_drug_letter: boolean\r\n  business_letter: boolean\r\n  country_id: number\r\n  max_declared_value: number\r\n  max_weight: number\r\n  min_weight: number\r\n  packaging: boolean\r\n  product_id: number\r\n  shipment_content_types: number[]\r\n  shipment_groups: number[]\r\n  shipment_scopes: number[]\r\n  local_name: string\r\n  insurance: number\r\n}\r\nexport type CountryReferenceProductOut = {\r\n  country_reference_product: CountryReferenceProduct\r\n}\r\n\r\nexport type ExtraChargeEntitiesIn = {\r\n  model_type?: string\r\n  model_id?: number\r\n  extracharge_entities: {\r\n    id: number\r\n    is_active: boolean\r\n  }[],\r\n  check_all?: boolean\r\n}\r\nexport type ExtraChargeEntitiesOut = {\r\n  extracharge_entities: ExtraChargeEntity[]\r\n  total: number\r\n}\r\n\r\nexport type ParameterConfigsOut = {\r\n  parameter_configs: ParameterConfig[]\r\n  total: number\r\n}\r\n\r\nexport type ParameterConfigIn = {\r\n  level: string\r\n  parameter_id: number\r\n  model_type: string\r\n  model_id: number\r\n  name: string\r\n  value: string\r\n}\r\nexport type ParameterConfigOut = {\r\n  parameter_config: ParameterConfig\r\n  total: number\r\n}\r\n\r\nexport type TDXAccountsSettingsOut = {\r\n  tdx_account_settings: TDXAccountSetting[]\r\n  total: number\r\n}\r\n\r\nexport type TDXAccountSettingsOut = {\r\n  tdx_account_settings: TDXAccountSetting\r\n}\r\n\r\nexport type TDXAccountSettingsIn = {\r\n  id?: number\r\n  location_id: number\r\n  account_id: number\r\n  product_id: number\r\n  is_active: boolean\r\n}\r\n\r\nexport type LocationEmployeesIn = { token: string } & QueryParams\r\n"]}

package/esm2022/lib/apis/models/api-external-ops.interfaces.mjs

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

package/esm2022/lib/apis/models/api-external-ops.types.mjs

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

package/esm2022/lib/apis/models/api-quote.interfaces.mjs

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

package/esm2022/lib/apis/models/api-quote.types.mjs

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

package/esm2022/lib/interceptors/api-key.interceptor.mjs

@@ -0,0 +1,48 @@
+import { inject } from '@angular/core';
+import { ENVIRONMENT_TOKEN } from '../ngx-services.models';
+/**
+ * HTTP interceptor that injects the external operations API key into outbound requests.
+ *
+ * The interceptor:
+ * 1. Reads `apiExternalOperationsKey` from the injected `ENVIRONMENT_TOKEN`.
+ * 2. Skips modification if the key is absent.
+ * 3. Leaves the request unchanged if it already contains an `AppKey` header (caller override).
+ * 4. Otherwise clones the request adding `AppKey: apiExternalOperationsKey`.
+ *
+ * This enables centralized, transparent authentication for services targeting external
+ * operations endpoints while allowing explicit per-request overrides.
+ *
+ * Example:
+ * ```ts
+ * provideHttpClient(
+ *   withInterceptors([apiKeyInterceptor])
+ * );
+ * ```
+ *
+ * @param request The original immutable `HttpRequest` instance.
+ * @param next The next handler in the interceptor chain, used to forward the (possibly cloned) request.
+ * @returns An `Observable` stream of the HTTP events for the (potentially augmented) request.
+ *
+ * @remarks
+ * - If you need to intentionally send a different key for a specific request, set the `AppKey`
+ *   header manually before this interceptor runs.
+ * - If `apiExternalOperationsKey` is undefined (e.g., missing configuration), the request is passed through unchanged.
+ * - Order matters: place this interceptor before others that rely on the presence of the `AppKey` header.
+ *
+ * @see HttpRequest
+ * @see HttpHandlerFn
+ */
+export function apiKeyInterceptor(request, next) {
+    const { apiExternalOperationsKey } = inject(ENVIRONMENT_TOKEN);
+    if (!apiExternalOperationsKey)
+        return next(request);
+    if (request.headers.has('AppKey'))
+        return next(request);
+    request = request.clone({
+        setHeaders: {
+            AppKey: apiExternalOperationsKey
+        }
+    });
+    return next(request);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/ngx-services.models.mjs

@@ -8,4 +8,4 @@ import { InjectionToken } from '@angular/core';
  * `Environment` type that defines the structure of the configuration.
  */
 export const ENVIRONMENT_TOKEN = new InjectionToken('Environments token');
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -15,13 +15,14 @@ export * from './lib/apis/api-companies.service';
 export * from './lib/apis/api-composition.service';
 export * from './lib/apis/api-customs.service';
 export * from './lib/apis/api-discounts.service';
-export * from './lib/apis/api-events.service';
 export * from './lib/apis/api-e-tools-auto-billing.service';
+export * from './lib/apis/api-events.service';
 export * from './lib/apis/api-external-pickups.service';
 export * from './lib/apis/api-inventories.service';
 export * from './lib/apis/api-invoices.service';
 export * from './lib/apis/api-notifications.service';
 export * from './lib/apis/api-open-items.service';
+export * from './lib/apis/api-quote.service';
 export * from './lib/apis/api-reports.service';
 export * from './lib/apis/api-security.service';
 export * from './lib/apis/api-services.service';
@@ -65,6 +66,8 @@ export * from './lib/apis/models/api-notifications.interfaces';
 export * from './lib/apis/models/api-notifications.types';
 export * from './lib/apis/models/api-open-items.interfaces';
 export * from './lib/apis/models/api-open-items.types';
+export * from './lib/apis/models/api-quote.interfaces';
+export * from './lib/apis/models/api-quote.types';
 export * from './lib/apis/models/api-reports.interfaces';
 export * from './lib/apis/models/api-reports.types';
 export * from './lib/apis/models/api-security.interfaces';
@@ -87,4 +90,4 @@ export * from './lib/interceptors/http-caching.interceptor';
 // helpers
 export * from './lib/helpers/http';
 export * from './lib/helpers/files';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../../projects/experteam-mx/ngx-services/src/public-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,2BAA2B,CAAA;AACzC,cAAc,2BAA2B,CAAA;AAEzC,eAAe;AACf,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,oCAAoC,CAAA;AAClD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,kCAAkC,CAAA;AAChD,cAAc,+BAA+B,CAAA;AAC7C,cAAc,6CAA6C,CAAA;AAC3D,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAE/C,aAAa;AACb,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,sCAAsC,CAAA;AACpD,cAAc,kDAAkD,CAAA;AAChE,cAAc,6CAA6C,CAAA;AAC3D,cAAc,oCAAoC,CAAA;AAClD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,uDAAuD,CAAA;AACrE,cAAc,kDAAkD,CAAA;AAChE,cAAc,mCAAmC,CAAA;AACjD,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,wCAAwC,CAAA;AACtD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,gDAAgD,CAAA;AAC9D,cAAc,2CAA2C,CAAA;AACzD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,8BAA8B,CAAA;AAE5C,aAAa;AACb,cAAc,sCAAsC,CAAA;AAEpD,SAAS;AACT,cAAc,6BAA6B,CAAA;AAE3C,eAAe;AACf,cAAc,4CAA4C,CAAA;AAC1D,cAAc,0CAA0C,CAAA;AACxD,cAAc,6CAA6C,CAAA;AAE3D,UAAU;AACV,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA","sourcesContent":["/*\r\n * Public API Surface of ngx-services\r\n */\r\nexport * from './lib/ngx-services.models'\r\nexport * from './lib/ngx-services.module'\r\n\r\n// api services\r\nexport * from './lib/apis/api-billing-do.service'\r\nexport * from './lib/apis/api-billing-gt.service'\r\nexport * from './lib/apis/api-billing-mx.service'\r\nexport * from './lib/apis/api-billing-pa.service'\r\nexport * from './lib/apis/api-billing-sv.service'\r\nexport * from './lib/apis/api-cash-operations.service'\r\nexport * from './lib/apis/api-catalogs.service'\r\nexport * from './lib/apis/api-companies.service'\r\nexport * from './lib/apis/api-composition.service'\r\nexport * from './lib/apis/api-customs.service'\r\nexport * from './lib/apis/api-discounts.service'\r\nexport * from './lib/apis/api-events.service'\r\nexport * from './lib/apis/api-e-tools-auto-billing.service'\r\nexport * from './lib/apis/api-external-pickups.service'\r\nexport * from './lib/apis/api-inventories.service'\r\nexport * from './lib/apis/api-invoices.service'\r\nexport * from './lib/apis/api-notifications.service'\r\nexport * from './lib/apis/api-open-items.service'\r\nexport * from './lib/apis/api-reports.service'\r\nexport * from './lib/apis/api-security.service'\r\nexport * from './lib/apis/api-services.service'\r\nexport * from './lib/apis/api-shipments.service'\r\nexport * from './lib/apis/api-supplies.service'\r\n\r\n// api models\r\nexport * from './lib/apis/models/api-billing-do.interfaces'\r\nexport * from './lib/apis/models/api-billing-do.types'\r\nexport * from './lib/apis/models/api-billing-mx.interfaces'\r\nexport * from './lib/apis/models/api-billing-mx.types'\r\nexport * from './lib/apis/models/api-billing-pa.interfaces'\r\nexport * from './lib/apis/models/api-billing-pa.types'\r\nexport * from './lib/apis/models/api-billing-sv.interfaces'\r\nexport * from './lib/apis/models/api-billing-sv.types'\r\nexport * from './lib/apis/models/api-billing.models'\r\nexport * from './lib/apis/models/api-cash-operations.interfaces'\r\nexport * from './lib/apis/models/api-cash-operations.types'\r\nexport * from './lib/apis/models/api-catalog.enum'\r\nexport * from './lib/apis/models/api-catalog.interfaces'\r\nexport * from './lib/apis/models/api-catalog.types'\r\nexport * from './lib/apis/models/api-companies.interfaces'\r\nexport * from './lib/apis/models/api-companies.types'\r\nexport * from './lib/apis/models/api-composition.interfaces'\r\nexport * from './lib/apis/models/api-composition.types'\r\nexport * from './lib/apis/models/api-customs.interfaces'\r\nexport * from './lib/apis/models/api-customs.types'\r\nexport * from './lib/apis/models/api-discounts.interfaces'\r\nexport * from './lib/apis/models/api-discounts.types'\r\nexport * from './lib/apis/models/api-e-tools-auto-billing.interfaces'\r\nexport * from './lib/apis/models/api-e-tools-auto-billing.types'\r\nexport * from './lib/apis/models/api-events.enum'\r\nexport * from './lib/apis/models/api-events.interfaces'\r\nexport * from './lib/apis/models/api-events.types'\r\nexport * from './lib/apis/models/api-external-pickups.types'\r\nexport * from './lib/apis/models/api-inventories.enum'\r\nexport * from './lib/apis/models/api-inventories.interfaces'\r\nexport * from './lib/apis/models/api-inventories.types'\r\nexport * from './lib/apis/models/api-invoices.interfaces'\r\nexport * from './lib/apis/models/api-invoices.types'\r\nexport * from './lib/apis/models/api-notifications.interfaces'\r\nexport * from './lib/apis/models/api-notifications.types'\r\nexport * from './lib/apis/models/api-open-items.interfaces'\r\nexport * from './lib/apis/models/api-open-items.types'\r\nexport * from './lib/apis/models/api-reports.interfaces'\r\nexport * from './lib/apis/models/api-reports.types'\r\nexport * from './lib/apis/models/api-security.interfaces'\r\nexport * from './lib/apis/models/api-security.types'\r\nexport * from './lib/apis/models/api-services.interfaces'\r\nexport * from './lib/apis/models/api-services.types'\r\nexport * from './lib/apis/models/api-shipments.interfaces'\r\nexport * from './lib/apis/models/api-shipments.types'\r\nexport * from './lib/apis/models/api-supplies.interfaces'\r\nexport * from './lib/apis/models/api-supplies.types'\r\nexport * from './lib/apis/models/api.models'\r\n\r\n// websockets\r\nexport * from './lib/websockets/web-sockets.service'\r\n\r\n// cypher\r\nexport * from './lib/cypher/crypto.service'\r\n\r\n// interceptors\r\nexport * from './lib/interceptors/api-headers.interceptor'\r\nexport * from './lib/interceptors/api-token.interceptor'\r\nexport * from './lib/interceptors/http-caching.interceptor'\r\n\r\n// helpers\r\nexport * from './lib/helpers/http'\r\nexport * from './lib/helpers/files'\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../../projects/experteam-mx/ngx-services/src/public-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,2BAA2B,CAAA;AACzC,cAAc,2BAA2B,CAAA;AAEzC,eAAe;AACf,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,oCAAoC,CAAA;AAClD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,kCAAkC,CAAA;AAChD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,+BAA+B,CAAA;AAC7C,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,mCAAmC,CAAA;AACjD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAE/C,aAAa;AACb,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,sCAAsC,CAAA;AACpD,cAAc,kDAAkD,CAAA;AAChE,cAAc,6CAA6C,CAAA;AAC3D,cAAc,oCAAoC,CAAA;AAClD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,uDAAuD,CAAA;AACrE,cAAc,kDAAkD,CAAA;AAChE,cAAc,mCAAmC,CAAA;AACjD,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,wCAAwC,CAAA;AACtD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,gDAAgD,CAAA;AAC9D,cAAc,2CAA2C,CAAA;AACzD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,wCAAwC,CAAA;AACtD,cAAc,wCAAwC,CAAA;AACtD,cAAc,mCAAmC,CAAA;AACjD,cAAc,0CAA0C,CAAA;AACxD,cAAc,qCAAqC,CAAA;AACnD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,uCAAuC,CAAA;AACrD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,8BAA8B,CAAA;AAE5C,aAAa;AACb,cAAc,sCAAsC,CAAA;AAEpD,SAAS;AACT,cAAc,6BAA6B,CAAA;AAE3C,eAAe;AACf,cAAc,4CAA4C,CAAA;AAC1D,cAAc,0CAA0C,CAAA;AACxD,cAAc,6CAA6C,CAAA;AAE3D,UAAU;AACV,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA","sourcesContent":["/*\r\n * Public API Surface of ngx-services\r\n */\r\nexport * from './lib/ngx-services.models'\r\nexport * from './lib/ngx-services.module'\r\n\r\n// api services\r\nexport * from './lib/apis/api-billing-do.service'\r\nexport * from './lib/apis/api-billing-gt.service'\r\nexport * from './lib/apis/api-billing-mx.service'\r\nexport * from './lib/apis/api-billing-pa.service'\r\nexport * from './lib/apis/api-billing-sv.service'\r\nexport * from './lib/apis/api-cash-operations.service'\r\nexport * from './lib/apis/api-catalogs.service'\r\nexport * from './lib/apis/api-companies.service'\r\nexport * from './lib/apis/api-composition.service'\r\nexport * from './lib/apis/api-customs.service'\r\nexport * from './lib/apis/api-discounts.service'\r\nexport * from './lib/apis/api-e-tools-auto-billing.service'\r\nexport * from './lib/apis/api-events.service'\r\nexport * from './lib/apis/api-external-pickups.service'\r\nexport * from './lib/apis/api-inventories.service'\r\nexport * from './lib/apis/api-invoices.service'\r\nexport * from './lib/apis/api-notifications.service'\r\nexport * from './lib/apis/api-open-items.service'\r\nexport * from './lib/apis/api-quote.service'\r\nexport * from './lib/apis/api-reports.service'\r\nexport * from './lib/apis/api-security.service'\r\nexport * from './lib/apis/api-services.service'\r\nexport * from './lib/apis/api-shipments.service'\r\nexport * from './lib/apis/api-supplies.service'\r\n\r\n// api models\r\nexport * from './lib/apis/models/api-billing-do.interfaces'\r\nexport * from './lib/apis/models/api-billing-do.types'\r\nexport * from './lib/apis/models/api-billing-mx.interfaces'\r\nexport * from './lib/apis/models/api-billing-mx.types'\r\nexport * from './lib/apis/models/api-billing-pa.interfaces'\r\nexport * from './lib/apis/models/api-billing-pa.types'\r\nexport * from './lib/apis/models/api-billing-sv.interfaces'\r\nexport * from './lib/apis/models/api-billing-sv.types'\r\nexport * from './lib/apis/models/api-billing.models'\r\nexport * from './lib/apis/models/api-cash-operations.interfaces'\r\nexport * from './lib/apis/models/api-cash-operations.types'\r\nexport * from './lib/apis/models/api-catalog.enum'\r\nexport * from './lib/apis/models/api-catalog.interfaces'\r\nexport * from './lib/apis/models/api-catalog.types'\r\nexport * from './lib/apis/models/api-companies.interfaces'\r\nexport * from './lib/apis/models/api-companies.types'\r\nexport * from './lib/apis/models/api-composition.interfaces'\r\nexport * from './lib/apis/models/api-composition.types'\r\nexport * from './lib/apis/models/api-customs.interfaces'\r\nexport * from './lib/apis/models/api-customs.types'\r\nexport * from './lib/apis/models/api-discounts.interfaces'\r\nexport * from './lib/apis/models/api-discounts.types'\r\nexport * from './lib/apis/models/api-e-tools-auto-billing.interfaces'\r\nexport * from './lib/apis/models/api-e-tools-auto-billing.types'\r\nexport * from './lib/apis/models/api-events.enum'\r\nexport * from './lib/apis/models/api-events.interfaces'\r\nexport * from './lib/apis/models/api-events.types'\r\nexport * from './lib/apis/models/api-external-pickups.types'\r\nexport * from './lib/apis/models/api-inventories.enum'\r\nexport * from './lib/apis/models/api-inventories.interfaces'\r\nexport * from './lib/apis/models/api-inventories.types'\r\nexport * from './lib/apis/models/api-invoices.interfaces'\r\nexport * from './lib/apis/models/api-invoices.types'\r\nexport * from './lib/apis/models/api-notifications.interfaces'\r\nexport * from './lib/apis/models/api-notifications.types'\r\nexport * from './lib/apis/models/api-open-items.interfaces'\r\nexport * from './lib/apis/models/api-open-items.types'\r\nexport * from './lib/apis/models/api-quote.interfaces'\r\nexport * from './lib/apis/models/api-quote.types'\r\nexport * from './lib/apis/models/api-reports.interfaces'\r\nexport * from './lib/apis/models/api-reports.types'\r\nexport * from './lib/apis/models/api-security.interfaces'\r\nexport * from './lib/apis/models/api-security.types'\r\nexport * from './lib/apis/models/api-services.interfaces'\r\nexport * from './lib/apis/models/api-services.types'\r\nexport * from './lib/apis/models/api-shipments.interfaces'\r\nexport * from './lib/apis/models/api-shipments.types'\r\nexport * from './lib/apis/models/api-supplies.interfaces'\r\nexport * from './lib/apis/models/api-supplies.types'\r\nexport * from './lib/apis/models/api.models'\r\n\r\n// websockets\r\nexport * from './lib/websockets/web-sockets.service'\r\n\r\n// cypher\r\nexport * from './lib/cypher/crypto.service'\r\n\r\n// interceptors\r\nexport * from './lib/interceptors/api-headers.interceptor'\r\nexport * from './lib/interceptors/api-token.interceptor'\r\nexport * from './lib/interceptors/http-caching.interceptor'\r\n\r\n// helpers\r\nexport * from './lib/helpers/http'\r\nexport * from './lib/helpers/files'\r\n"]}