@experteam-mx/ngx-services 18.7.11 → 18.7.13

package/esm2022/lib/apis/api-cash-operations.service.mjs

@@ -48,6 +48,36 @@ export class ApiCashOperationsService {
             params
         }).pipe(map(({ data }) => data));
     }
+    /**
+     * Retrieves the cash value summary for a specific opening ID.
+     *
+     * @param {number} id - The ID of the opening for which to retrieve the cash value summary.
+     * @returns {Observable<CashValueSummaryOut>} An observable that emits the cash value summary data.
+     */
+    getOpeningCashValueSummary(id) {
+        return this.http.get(`${this.url}/openings/${id}/cash-value-summary`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new opening transference record.
+     *
+     * @param {OpeningTransferenceIn} body - The data to create the new opening transference.
+     * @returns {Observable<OpeningTransferenceOut>} An observable that emits the newly created opening transference.
+     */
+    postOpeningTransferences(body) {
+        return this.http.post(`${this.url}/opening-transferences`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the receipt file associated with the given opening transference ID.
+     *
+     * @param {number} id - The ID of the opening transference whose receipt is to be retrieved.
+     * @returns {Observable<ReceiptFileOut>} An observable that emits the receipt file data.
+     */
+    getOpeningTransferenceReceipt(id) {
+        return this.http.get(`${this.url}/opening-transferences/${id}/receipt`)
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCashOperationsService, 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: ApiCashOperationsService, providedIn: 'root' });
 }
@@ -60,4 +90,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-cash-operations.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-cash-operations.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAIlD,OAAO,EAAE,GAAG,EAAc,MAAM,MAAM,CAAA;;;AAWtC,MAAM,OAAO,wBAAwB;IAEV;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,oBAAoB,IAAI,EAAE,CAAA;IACrD,CAAC;IAED;;;;;OAKG;IACH,wCAAwC,CAAE,IAA4C;QACpF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAsD,GAAG,IAAI,CAAC,GAAG,4CAA4C,EAChI,IAAI,CACL,CAAC,IAAI,CACJ,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CACxB,CAAA;IACH,CAAC;IAED;;;;;;OAMG;IACH,uCAAuC,CAAE,EAAS,EAAE,IAA4C;QAC9F,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAsD,GAAG,IAAI,CAAC,GAAG,8CAA8C,EAAE,EAAE,EAAE,IAAI,CAAC;aAC3I,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,uCAAuC,CAAE,MAAmB;QAC1D,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAwD,GAAG,IAAI,CAAC,GAAG,4CAA4C,EAAE;YACnI,MAAM;SACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,0BAA0B,CAAE,EAAU;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAkC,GAAG,IAAI,CAAC,GAAG,aAAa,EAAE,qBAAqB,CAAC;aACnG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,wBAAwB,CAAE,IAA2B;QACnD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAqC,GAAG,IAAI,CAAC,GAAG,wBAAwB,EAAE,IAAI,CAAC;aACjG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,6BAA6B,CAAE,EAAU;QACvC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA6B,GAAG,IAAI,CAAC,GAAG,0BAA0B,EAAE,UAAU,CAAC;aAChG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;wGApFU,wBAAwB,kBAEzB,KAAK;4GAFJ,wBAAwB,cAFvB,MAAM;;4FAEP,wBAAwB;kBAHpC,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 {\r\n  CashValueSummaryOut,\r\n  InstallationCountryReferenceCurrenciesOut,\r\n  InstallationCountryReferenceCurrencyIn,\r\n  InstallationCountryReferenceCurrencyOut, OpeningTransferenceIn, OpeningTransferenceOut, ReceiptFileOut\r\n} from './models/api-cash-operations.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCashOperationsService {\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 cash operations API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the cash operations API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCashOperationsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Creates a new installation country reference currency.\r\n   *\r\n   * @param {InstallationCountryReferenceCurrencyIn} body - The data for the new reference currency.\r\n   * @returns {Observable<InstallationCountryReferenceCurrencyOut>} The created reference currency.\r\n   */\r\n  postInstallationCountryReferenceCurrency (body: InstallationCountryReferenceCurrencyIn): Observable<InstallationCountryReferenceCurrencyOut> {\r\n    return this.http.post<ApiSuccess<InstallationCountryReferenceCurrencyOut>>(`${this.url}/installation-country-reference-currencies`,\r\n      body\r\n    ).pipe(\r\n      map(({ data }) => data)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Updates an existing installation country reference currency.\r\n   *\r\n   * @param {number} id - The ID of the reference currency to update.\r\n   * @param {InstallationCountryReferenceCurrencyIn} body - The updated data for the reference currency.\r\n   * @returns {Observable<InstallationCountryReferenceCurrencyOut>} The updated reference currency.\r\n   */\r\n  putInstallationCountryReferenceCurrency (id:number, body: InstallationCountryReferenceCurrencyIn): Observable<InstallationCountryReferenceCurrencyOut> {\r\n    return this.http.put<ApiSuccess<InstallationCountryReferenceCurrencyOut>>(`${this.url}/installation-country-reference-currencies/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of installation country reference currencies based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the currencies.\r\n   * @returns {Observable<InstallationCountryReferenceCurrenciesOut>} The list of reference currencies.\r\n   */\r\n  getInstallationCompanyCountryCurrencies (params: QueryParams): Observable<InstallationCountryReferenceCurrenciesOut> {\r\n    return this.http.get<ApiSuccess<InstallationCountryReferenceCurrenciesOut>>(`${this.url}/installation-country-reference-currencies`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the cash value summary for a specific opening ID.\r\n   *\r\n   * @param {number} id - The ID of the opening for which to retrieve the cash value summary.\r\n   * @returns {Observable<CashValueSummaryOut>} An observable that emits the cash value summary data.\r\n   */\r\n  getOpeningCashValueSummary (id: number): Observable<CashValueSummaryOut> {\r\n    return this.http.get<ApiSuccess<CashValueSummaryOut>>(`${this.url}/openings/${id}/cash-value-summary`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new opening transference record.\r\n   *\r\n   * @param {OpeningTransferenceIn} body - The data to create the new opening transference.\r\n   * @returns {Observable<OpeningTransferenceOut>} An observable that emits the newly created opening transference.\r\n   */\r\n  postOpeningTransferences (body: OpeningTransferenceIn): Observable<OpeningTransferenceOut> {\r\n    return this.http.post<ApiSuccess<OpeningTransferenceOut>>(`${this.url}/opening-transferences`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the receipt file associated with the given opening transference ID.\r\n   *\r\n   * @param {number} id - The ID of the opening transference whose receipt is to be retrieved.\r\n   * @returns {Observable<ReceiptFileOut>} An observable that emits the receipt file data.\r\n   */\r\n  getOpeningTransferenceReceipt (id: number): Observable<ReceiptFileOut> {\r\n    return this.http.get<ApiSuccess<ReceiptFileOut>>(`${this.url}/opening-transferences/${id}/receipt`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

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

@@ -127,6 +127,18 @@ export class ApiReportsService {
         return this.http.delete(`${this.url}/file-check/${transactionId}`)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Retrieves partial withdrawals based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters used to filter the list of partial withdrawals.
+     * @returns {Observable<PartialWithdrawalsOut>} An observable that emits the filtered list of partial withdrawals.
+     */
+    getPartialWithdrawals(params) {
+        return this.http.get(`${this.url}/partial-withdrawals`, {
+            params
+        })
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiReportsService, 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: ApiReportsService, providedIn: 'root' });
 }
@@ -139,4 +151,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-reports.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-reports.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient, HttpResponse } from '@angular/common/http'\r\nimport { map, Observable } from 'rxjs'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport {\r\n  CollectionPaymentsOut,\r\n  ExistPendingInvoicesIn,\r\n  ExistPendingPaymentsIn,\r\n  ExternalShipmentsOut,\r\n  FileCheckOut,\r\n  PromotionCodeDiscountsOut,\r\n  ShipmentsReportOut\r\n} from './models/api-reports.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiReportsService {\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 reports API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the reports API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiReportsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of collection payments\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the collection payments.\r\n   * @return {Observable<CollectionPaymentsOut[]>} An observable that emits an array of collection payment.\r\n   */\r\n  getCollectionPayments (params: QueryParams): Observable<CollectionPaymentsOut> {\r\n    return this.http.get<ApiSuccess<CollectionPaymentsOut>>(`${this.url}/collection-payment`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of shipments with pending payments.\r\n   *\r\n   * @param {ExistPendingPaymentsIn} params - The parameters to filter pending payment shipments.\r\n   * @return {Observable<ShipmentsReportOut>} An observable emitting the shipments report data.\r\n   */\r\n  shipmentsPendingPayments (params: ExistPendingPaymentsIn): Observable<ShipmentsReportOut> {\r\n    return this.http.get<ApiSuccess<ShipmentsReportOut>>(`${this.url}/shipments-report`, {\r\n      params: {\r\n        ...params,\r\n        limit: 1,\r\n        offset: 0,\r\n        to_landing: true,\r\n        shipment_status_code: 'PMPEN',\r\n      },\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches shipment reports that are pending invoices based on the specified parameters.\r\n   * This method retrieves a filtered list of shipments with pending invoice statuses.\r\n   *\r\n   * @param {ExistPendingInvoicesIn} params - The parameters to filter the pending invoices, including\r\n   *                                           shipment status codes, and pagination options.\r\n   * @return {Observable<ShipmentsReportOut>} An observable that emits the shipment report data based on the filter criteria.\r\n   */\r\n  shipmentsPendingInvoices (params: ExistPendingInvoicesIn): Observable<ShipmentsReportOut> {\r\n    return this.http.get<ApiSuccess<ShipmentsReportOut>>(`${this.url}/shipments-report`, {\r\n      params: {\r\n        ...params,\r\n        limit: 1,\r\n        offset: 0,\r\n        to_landing: true,\r\n        'shipment_status_code[in]': 'IPMPE,IMPEN,IPPEN',\r\n      },\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches shipment reports based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter or define the shipment reports.\r\n   * @return {Observable<ShipmentsReportOut>} An observable emitting the shipment report data.\r\n   */\r\n  getShipmentsReport (params: QueryParams): Observable<ShipmentsReportOut> {\r\n    return this.http.get<ApiSuccess<ShipmentsReportOut>>(`${this.url}/shipments-report`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a report of external shipments based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - An object representing the query parameters for filtering the external shipments report.\r\n   * @return {Observable<ExternalShipmentsOut>} An observable that emits the external shipments report data.\r\n   */\r\n  getExternalShipmentsReport (params: QueryParams): Observable<ExternalShipmentsOut> {\r\n    return this.http.get<ApiSuccess<ExternalShipmentsOut>>(`${this.url}/external-shipments-report`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a report of promotion code discounts based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - An object representing the query parameters for filtering the promotion code discounts report.\r\n   * @return {Observable<PromotionCodeDiscountsOut>} An observable that emits the promotion code discounts report data.\r\n   */\r\n  getPromotionCodeDiscounts (params: QueryParams): Observable<PromotionCodeDiscountsOut> {\r\n    return this.http.get<ApiSuccess<PromotionCodeDiscountsOut>>(`${this.url}/promotion-code-discounts`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the downloadable resource associated with the given transaction ID.\r\n   *\r\n   * @param {string} transactionId - The unique identifier of the transaction whose download is requested.\r\n   * @return {Observable<HttpResponse<ArrayBuffer>>} An observable that emits the HTTP response containing the resource in the form of an ArrayBuffer.\r\n   */\r\n  getDownload (transactionId: string): Observable<HttpResponse<ArrayBuffer>> {\r\n    return this.http.get(`${this.url}/download/${transactionId}`, {\r\n      observe: 'response',\r\n      responseType: 'arraybuffer'\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Retrieves file check information for the specified transaction ID.\r\n   *\r\n   * @param {string} transactionId - The ID of the transaction for which the file check information is to be retrieved.\r\n   * @return {Observable<FileCheckOut>} An observable that emits the file check information associated with the given transaction ID.\r\n   */\r\n  getFileCheck (transactionId: string): Observable<FileCheckOut> {\r\n    return this.http.get<ApiSuccess<FileCheckOut>>(`${this.url}/file-check/${transactionId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes the file check associated with the provided transaction ID.\r\n   *\r\n   * @param {string} transactionId - The unique identifier of the transaction whose file check is to be deleted.\r\n   * @return {Observable<{}>} An observable emitting the response data after the deletion is processed.\r\n   */\r\n  deleteFileCheck (transactionId: string): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/file-check/${transactionId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-reports.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-reports.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient, HttpResponse } from '@angular/common/http'\r\nimport { map, Observable } from 'rxjs'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport {\r\n  CollectionPaymentsOut,\r\n  ExistPendingInvoicesIn,\r\n  ExistPendingPaymentsIn,\r\n  ExternalShipmentsOut,\r\n  FileCheckOut, PartialWithdrawalsOut,\r\n  PromotionCodeDiscountsOut,\r\n  ShipmentsReportOut\r\n} from './models/api-reports.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiReportsService {\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 reports API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the reports API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiReportsUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of collection payments\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the collection payments.\r\n   * @return {Observable<CollectionPaymentsOut[]>} An observable that emits an array of collection payment.\r\n   */\r\n  getCollectionPayments (params: QueryParams): Observable<CollectionPaymentsOut> {\r\n    return this.http.get<ApiSuccess<CollectionPaymentsOut>>(`${this.url}/collection-payment`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of shipments with pending payments.\r\n   *\r\n   * @param {ExistPendingPaymentsIn} params - The parameters to filter pending payment shipments.\r\n   * @return {Observable<ShipmentsReportOut>} An observable emitting the shipments report data.\r\n   */\r\n  shipmentsPendingPayments (params: ExistPendingPaymentsIn): Observable<ShipmentsReportOut> {\r\n    return this.http.get<ApiSuccess<ShipmentsReportOut>>(`${this.url}/shipments-report`, {\r\n      params: {\r\n        ...params,\r\n        limit: 1,\r\n        offset: 0,\r\n        to_landing: true,\r\n        shipment_status_code: 'PMPEN',\r\n      },\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches shipment reports that are pending invoices based on the specified parameters.\r\n   * This method retrieves a filtered list of shipments with pending invoice statuses.\r\n   *\r\n   * @param {ExistPendingInvoicesIn} params - The parameters to filter the pending invoices, including\r\n   *                                           shipment status codes, and pagination options.\r\n   * @return {Observable<ShipmentsReportOut>} An observable that emits the shipment report data based on the filter criteria.\r\n   */\r\n  shipmentsPendingInvoices (params: ExistPendingInvoicesIn): Observable<ShipmentsReportOut> {\r\n    return this.http.get<ApiSuccess<ShipmentsReportOut>>(`${this.url}/shipments-report`, {\r\n      params: {\r\n        ...params,\r\n        limit: 1,\r\n        offset: 0,\r\n        to_landing: true,\r\n        'shipment_status_code[in]': 'IPMPE,IMPEN,IPPEN',\r\n      },\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches shipment reports based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter or define the shipment reports.\r\n   * @return {Observable<ShipmentsReportOut>} An observable emitting the shipment report data.\r\n   */\r\n  getShipmentsReport (params: QueryParams): Observable<ShipmentsReportOut> {\r\n    return this.http.get<ApiSuccess<ShipmentsReportOut>>(`${this.url}/shipments-report`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a report of external shipments based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - An object representing the query parameters for filtering the external shipments report.\r\n   * @return {Observable<ExternalShipmentsOut>} An observable that emits the external shipments report data.\r\n   */\r\n  getExternalShipmentsReport (params: QueryParams): Observable<ExternalShipmentsOut> {\r\n    return this.http.get<ApiSuccess<ExternalShipmentsOut>>(`${this.url}/external-shipments-report`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a report of promotion code discounts based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - An object representing the query parameters for filtering the promotion code discounts report.\r\n   * @return {Observable<PromotionCodeDiscountsOut>} An observable that emits the promotion code discounts report data.\r\n   */\r\n  getPromotionCodeDiscounts (params: QueryParams): Observable<PromotionCodeDiscountsOut> {\r\n    return this.http.get<ApiSuccess<PromotionCodeDiscountsOut>>(`${this.url}/promotion-code-discounts`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the downloadable resource associated with the given transaction ID.\r\n   *\r\n   * @param {string} transactionId - The unique identifier of the transaction whose download is requested.\r\n   * @return {Observable<HttpResponse<ArrayBuffer>>} An observable that emits the HTTP response containing the resource in the form of an ArrayBuffer.\r\n   */\r\n  getDownload (transactionId: string): Observable<HttpResponse<ArrayBuffer>> {\r\n    return this.http.get(`${this.url}/download/${transactionId}`, {\r\n      observe: 'response',\r\n      responseType: 'arraybuffer'\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Retrieves file check information for the specified transaction ID.\r\n   *\r\n   * @param {string} transactionId - The ID of the transaction for which the file check information is to be retrieved.\r\n   * @return {Observable<FileCheckOut>} An observable that emits the file check information associated with the given transaction ID.\r\n   */\r\n  getFileCheck (transactionId: string): Observable<FileCheckOut> {\r\n    return this.http.get<ApiSuccess<FileCheckOut>>(`${this.url}/file-check/${transactionId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Deletes the file check associated with the provided transaction ID.\r\n   *\r\n   * @param {string} transactionId - The unique identifier of the transaction whose file check is to be deleted.\r\n   * @return {Observable<{}>} An observable emitting the response data after the deletion is processed.\r\n   */\r\n  deleteFileCheck (transactionId: string): Observable<{}> {\r\n    return this.http.delete<ApiSuccess<{}>>(`${this.url}/file-check/${transactionId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves partial withdrawals based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter the list of partial withdrawals.\r\n   * @returns {Observable<PartialWithdrawalsOut>} An observable that emits the filtered list of partial withdrawals.\r\n   */\r\n  getPartialWithdrawals (params: QueryParams): Observable<PartialWithdrawalsOut> {\r\n    return this.http.get<ApiSuccess<PartialWithdrawalsOut>>(`${this.url}/partial-withdrawals`, {\r\n      params\r\n    })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,93 @@
+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 ApiServicesService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the services API from the environment settings.
+     * If the URL is not defined, an empty string is returned.
+     *
+     * @return {string} The API Services URL or an empty string if not defined.
+     */
+    get url() {
+        return this.environments.apiServicesUrl ?? '';
+    }
+    /**
+     * Retrieves service areas based on the provided query parameters.
+     *
+     * @param {ServiceAreaIn} body - The query parameters used to filter and retrieve service areas.
+     * @return {Observable<NotificationsOut>} An observable that emits the fetched service areas.
+     */
+    postServiceAreas(body) {
+        return this.http.post(`${this.url}/service-areas`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Validate facility values based on the provided parameter.
+     *
+     * @param {ValidateFacilityIn} body - The facility data to be sent in the request body
+     * @return {Observable<ValidateFacilityOut>} An observable emitting the response containing the facility validated output data.
+     */
+    postValidateFacility(body) {
+        return this.http.post(`${this.url}/facilities`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Create an email resource.
+     *
+     * @param {EmailErrorIn} body - The email data to be sent in the request body
+     * @return {Observable<{}>} An observable emitting the response data.
+     */
+    postEmailError(body) {
+        return this.http.post(`${this.url}/emails/error`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a promotion request to the server using the provided body.
+     *
+     * @param {PromotionIn} body - The promotion data to be sent in the request body.
+     * @return {Observable<PromotionOut>} An observable emitting the response containing the promotion output data.
+     */
+    postPromotion(body) {
+        return this.http.post(`${this.url}/promotions`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Validate NIP account value based on the provided parameter.
+     *
+     * @param {ValidateNIPIn} body - The NIP account data to be sent in the request body
+     * @return {Observable<ValidateNIPOut>} An observable emitting the response containing the NIP account validated data.
+     */
+    postValidateNIP(body) {
+        return this.http.post(`${this.url}/accounts/nip`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Validate BR Identification value based on the provided parameter.
+     *
+     * @param {ValidateIdentificationBRIn} body - The BR Identification data to be sent in the request body
+     * @return {Observable<ValidateIdentificationBROut>} An observable emitting the response containing the BR Identification validated data.
+     */
+    postValidateIdentificationBR(body) {
+        return this.http.post(`${this.url}/identifications/br-validation`, body)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiServicesService, 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: ApiServicesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiServicesService, 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-services.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-services.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAIlD,OAAO,EAAE,GAAG,EAAc,MAAM,MAAM,CAAA;;;AAkBtC,MAAM,OAAO,kBAAkB;IAEJ;IACf;IAFV,YACyB,YAAyB,EACxC,IAAgB;QADD,iBAAY,GAAZ,YAAY,CAAa;QACxC,SAAI,GAAJ,IAAI,CAAY;IACvB,CAAC;IAEJ;;;;;OAKG;IACH,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,IAAI,EAAE,CAAA;IAC/C,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAE,IAAmB;QACnC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA8B,GAAG,IAAI,CAAC,GAAG,gBAAgB,EAAE,IAAI,CAAC;aAClF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,oBAAoB,CAAE,IAAwB;QAC5C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAkC,GAAG,IAAI,CAAC,GAAG,aAAa,EAAE,IAAI,CAAC;aACnF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAE,IAAkB;QAChC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiB,GAAG,IAAI,CAAC,GAAG,eAAe,EAAE,IAAI,CAAC;aACpE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,aAAa,CAAE,IAAiB;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA2B,GAAG,IAAI,CAAC,GAAG,aAAa,EAAE,IAAI,CAAC;aAC5E,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAE,IAAmB;QAClC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA6B,GAAG,IAAI,CAAC,GAAG,eAAe,EAAE,IAAI,CAAC;aAChF,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,gCAAgC,EAAE,IAAI,CAAC;aAC9G,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;wGAhFU,kBAAkB,kBAEnB,KAAK;4GAFJ,kBAAkB,cAHjB,MAAM;;4FAGP,kBAAkB;kBAJ9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAII,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 } from './models/api.models'\r\nimport { map, Observable } from 'rxjs'\r\nimport {\r\n  ValidateFacilityIn,\r\n  ValidateFacilityOut,\r\n  ServiceAreasOut,\r\n  EmailErrorIn,\r\n  PromotionIn,\r\n  PromotionOut,\r\n  ValidateNIPOut,\r\n  ValidateNIPIn,\r\n  ValidateIdentificationBROut,\r\n  ValidateIdentificationBRIn, ServiceAreaIn\r\n} from './models/api-services.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\n\r\nexport class ApiServicesService {\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 services API from the environment settings.\r\n   * If the URL is not defined, an empty string is returned.\r\n   *\r\n   * @return {string} The API Services URL or an empty string if not defined.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiServicesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves service areas based on the provided query parameters.\r\n   *\r\n   * @param {ServiceAreaIn} body - The query parameters used to filter and retrieve service areas.\r\n   * @return {Observable<NotificationsOut>} An observable that emits the fetched service areas.\r\n   */\r\n  postServiceAreas (body: ServiceAreaIn): Observable<ServiceAreasOut> {\r\n    return this.http.post<ApiSuccess<ServiceAreasOut>>(`${this.url}/service-areas`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Validate facility values based on the provided parameter.\r\n   *\r\n   * @param {ValidateFacilityIn} body - The facility data to be sent in the request body\r\n   * @return {Observable<ValidateFacilityOut>} An observable emitting the response containing the facility validated output data.\r\n   */\r\n  postValidateFacility (body: ValidateFacilityIn): Observable<ValidateFacilityOut> {\r\n    return this.http.post<ApiSuccess<ValidateFacilityOut>>(`${this.url}/facilities`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create an email resource.\r\n   *\r\n   * @param {EmailErrorIn} body - The email data to be sent in the request body\r\n   * @return {Observable<{}>} An observable emitting the response data.\r\n   */\r\n  postEmailError (body: EmailErrorIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/emails/error`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a promotion request to the server using the provided body.\r\n   *\r\n   * @param {PromotionIn} body - The promotion data to be sent in the request body.\r\n   * @return {Observable<PromotionOut>} An observable emitting the response containing the promotion output data.\r\n   */\r\n  postPromotion (body: PromotionIn): Observable<PromotionOut> {\r\n    return this.http.post<ApiSuccess<PromotionOut>>(`${this.url}/promotions`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Validate NIP account value based on the provided parameter.\r\n   *\r\n   * @param {ValidateNIPIn} body - The NIP account data to be sent in the request body\r\n   * @return {Observable<ValidateNIPOut>} An observable emitting the response containing the NIP account validated data.\r\n   */\r\n  postValidateNIP (body: ValidateNIPIn): Observable<ValidateNIPOut> {\r\n    return this.http.post<ApiSuccess<ValidateNIPOut>>(`${this.url}/accounts/nip`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Validate BR Identification value based on the provided parameter.\r\n   *\r\n   * @param {ValidateIdentificationBRIn} body - The BR Identification data to be sent in the request body\r\n   * @return {Observable<ValidateIdentificationBROut>} An observable emitting the response containing the BR Identification validated data.\r\n   */\r\n  postValidateIdentificationBR (body: ValidateIdentificationBRIn): Observable<ValidateIdentificationBROut> {\r\n    return this.http.post<ApiSuccess<ValidateIdentificationBROut>>(`${this.url}/identifications/br-validation`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,83 @@
+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 ApiSuppliesService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the API supplies endpoint.
+     *
+     * @return {string} The API supplies URL or an empty string if not defined.
+     */
+    get url() {
+        return this.environments.apiSuppliesUrl ?? '';
+    }
+    /**
+     * Fetches a list of supplies based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the supplies.
+     * @return {Observable<SuppliesOut>} An observable containing the list of supplies.
+     */
+    getSupplies(params) {
+        return this.http.get(`${this.url}/supplies`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the supply details for a given supply ID.
+     *
+     * @param {number} id - The unique identifier of the supply to retrieve.
+     * @return {Observable<SupplyOut>} An observable containing the supply details.
+     */
+    getSupply(id) {
+        return this.http.get(`${this.url}/supplies/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a supply object to the server and returns the created or updated supply information.
+     *
+     * @param {SupplyIn} body - The supply information to be sent to the server.
+     * @return {Observable<SupplyOut>} An observable containing the response with the supply data.
+     */
+    postSupply(body) {
+        return this.http.post(`${this.url}/supplies`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing supply with the provided data.
+     *
+     * @param {number} id - The unique identifier of the supply to update.
+     * @param {SupplyIn} body - The data to update the supply with.
+     * @return {Observable<SupplyOut>} An observable containing the updated supply information.
+     */
+    putSupply(id, body) {
+        return this.http.put(`${this.url}/supplies/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the supply types based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the supply types.
+     * @return {Observable<SupplyTypesOut>} An Observable that emits the supply types data.
+     */
+    getSupplyTypes(params) {
+        return this.http.get(`${this.url}/supply-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiSuppliesService, 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: ApiSuppliesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiSuppliesService, 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/models/api-cash-operations.interfaces.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWNhc2gtb3BlcmF0aW9ucy5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXhwZXJ0ZWFtLW14L25neC1zZXJ2aWNlcy9zcmMvbGliL2FwaXMvbW9kZWxzL2FwaS1jYXNoLW9wZXJhdGlvbnMuaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWN0aXZlTGVzc1N5bWZvbnlNb2RlbCB9IGZyb20gJy4vYXBpLm1vZGVscydcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSW5zdGFsbGF0aW9uQ291bnRyeVJlZmVyZW5jZUN1cnJlbmN5IGV4dGVuZHMgQWN0aXZlTGVzc1N5bWZvbnlNb2RlbCB7XHJcbiAgaW5zdGFsbGF0aW9uSWQ/OiBudW1iZXIsXHJcbiAgY291bnRyeVJlZmVyZW5jZUN1cnJlbmN5SWQ6IG51bWJlcixcclxuICBtaW5DYXNoVmFsdWU/OiBudW1iZXIsXHJcbiAgbWF4Q2FzaFZhbHVlPzogbnVtYmVyXHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWNhc2gtb3BlcmF0aW9ucy5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXhwZXJ0ZWFtLW14L25neC1zZXJ2aWNlcy9zcmMvbGliL2FwaXMvbW9kZWxzL2FwaS1jYXNoLW9wZXJhdGlvbnMuaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWN0aXZlTGVzc1N5bWZvbnlNb2RlbCwgU3ltZm9ueU1vZGVsIH0gZnJvbSAnLi9hcGkubW9kZWxzJ1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBJbnN0YWxsYXRpb25Db3VudHJ5UmVmZXJlbmNlQ3VycmVuY3kgZXh0ZW5kcyBBY3RpdmVMZXNzU3ltZm9ueU1vZGVsIHtcclxuICBpbnN0YWxsYXRpb25JZD86IG51bWJlcixcclxuICBjb3VudHJ5UmVmZXJlbmNlQ3VycmVuY3lJZDogbnVtYmVyLFxyXG4gIG1pbkNhc2hWYWx1ZT86IG51bWJlcixcclxuICBtYXhDYXNoVmFsdWU/OiBudW1iZXJcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBDYXNoVmFsdWVTdW1tYXJ5IHtcclxuICBjb3VudHJ5UmVmZXJlbmNlQ3VycmVuY3lJZDogbnVtYmVyXHJcbiAgY3VycmVuY3lDb2RlOiBzdHJpbmdcclxuICBiYWxhbmNlSW5pdGlhbDogbnVtYmVyXHJcbiAgdHJhbnNmZXJzOiBudW1iZXJcclxuICBwYXltZW50czogbnVtYmVyXHJcbiAgdG90YWxCYWxhbmNlOiBudW1iZXJcclxuICBtaW5DYXNoVmFsdWU6IG51bWJlclxyXG4gIG1heEFtb3VudDogbnVtYmVyXHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgT3BlbmluZ1RyYW5zZmVyZW5jZSBleHRlbmRzIEFjdGl2ZUxlc3NTeW1mb255TW9kZWwge1xyXG4gIG9wZW5pbmdJZDogbnVtYmVyXHJcbiAgb3BlbmluZ1JlZmVyZW5jZUlkOiBudW1iZXJcclxuICB0cmFuc2ZlcmVuY2VUeXBlSWQ6IG51bWJlclxyXG4gIHVzZXJJZDogbnVtYmVyXHJcbiAgYW1vdW50OiBudW1iZXJcclxuICBjb3VudHJ5UmVmZXJlbmNlQ3VycmVuY3lJZDogbnVtYmVyXHJcbiAgdHJhbnNmZXJlbmNlQ29kZTogc3RyaW5nXHJcbiAgcmVjZWlwdE51bWJlcjogc3RyaW5nXHJcbiAgdXNlck5hbWU6IHN0cmluZyB8IG51bGxcclxuICB1c2VyVXNlcm5hbWU6IHN0cmluZyB8IG51bGxcclxuICBjdXJyZW5jeUNvZGU6IHN0cmluZyB8IG51bGxcclxuICBtYXhDYXNoRXhjZWVkZWQ6IGJvb2xlYW5cclxuICB0cmFuc2ZlcmVuY2VUeXBlOiBUcmFuc2ZlcmVuY2VUeXBlXHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgUmVjZWlwdEZpbGUge1xyXG4gIGZvcm1hdDogc3RyaW5nXHJcbiAgYmFzZTY0OiBzdHJpbmdcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBUcmFuc2ZlcmVuY2VUeXBlIGV4dGVuZHMgU3ltZm9ueU1vZGVsIHtcclxuICBjb2RlOiBzdHJpbmdcclxuICBuYW1lOiBzdHJpbmdcclxufVxyXG4iXX0=

package/esm2022/lib/apis/models/api-cash-operations.types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWNhc2gtb3BlcmF0aW9ucy50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2V4cGVydGVhbS1teC9uZ3gtc2VydmljZXMvc3JjL2xpYi9hcGlzL21vZGVscy9hcGktY2FzaC1vcGVyYXRpb25zLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbnN0YWxsYXRpb25Db3VudHJ5UmVmZXJlbmNlQ3VycmVuY3kgfSBmcm9tICcuL2FwaS1jYXNoLW9wZXJhdGlvbnMuaW50ZXJmYWNlcydcclxuXHJcbmV4cG9ydCB0eXBlIEluc3RhbGxhdGlvbkNvdW50cnlSZWZlcmVuY2VDdXJyZW5jaWVzT3V0ID0ge1xyXG4gIHRvdGFsOiBudW1iZXIsXHJcbiAgaW5zdGFsbGF0aW9uQ291bnRyeVJlZmVyZW5jZUN1cnJlbmNpZXM6IEluc3RhbGxhdGlvbkNvdW50cnlSZWZlcmVuY2VDdXJyZW5jeVtdXHJcbn1cclxuXHJcbmV4cG9ydCB0eXBlIEluc3RhbGxhdGlvbkNvdW50cnlSZWZlcmVuY2VDdXJyZW5jeUluID0ge1xyXG4gIGluc3RhbGxhdGlvbklkPzogbnVtYmVyLFxyXG4gIGNvdW50cnlSZWZlcmVuY2VDdXJyZW5jeUlkOiBudW1iZXIsXHJcbiAgbWluQ2FzaFZhbHVlPzogbnVtYmVyLFxyXG4gIG1heENhc2hWYWx1ZT86IG51bWJlclxyXG59XHJcblxyXG5leHBvcnQgdHlwZSBJbnN0YWxsYXRpb25Db3VudHJ5UmVmZXJlbmNlQ3VycmVuY3lPdXQgPSB7XHJcbiAgaW5zdGFsbGF0aW9uQ291bnRyeVJlZmVyZW5jZUN1cnJlbmNpZXM6IEluc3RhbGxhdGlvbkNvdW50cnlSZWZlcmVuY2VDdXJyZW5jeVxyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWNhc2gtb3BlcmF0aW9ucy50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2V4cGVydGVhbS1teC9uZ3gtc2VydmljZXMvc3JjL2xpYi9hcGlzL21vZGVscy9hcGktY2FzaC1vcGVyYXRpb25zLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xyXG4gIENhc2hWYWx1ZVN1bW1hcnksXHJcbiAgSW5zdGFsbGF0aW9uQ291bnRyeVJlZmVyZW5jZUN1cnJlbmN5LFxyXG4gIE9wZW5pbmdUcmFuc2ZlcmVuY2UsIFJlY2VpcHRGaWxlXHJcbn0gZnJvbSAnLi9hcGktY2FzaC1vcGVyYXRpb25zLmludGVyZmFjZXMnXHJcblxyXG5leHBvcnQgdHlwZSBJbnN0YWxsYXRpb25Db3VudHJ5UmVmZXJlbmNlQ3VycmVuY2llc091dCA9IHtcclxuICB0b3RhbDogbnVtYmVyLFxyXG4gIGluc3RhbGxhdGlvbkNvdW50cnlSZWZlcmVuY2VDdXJyZW5jaWVzOiBJbnN0YWxsYXRpb25Db3VudHJ5UmVmZXJlbmNlQ3VycmVuY3lbXVxyXG59XHJcblxyXG5leHBvcnQgdHlwZSBJbnN0YWxsYXRpb25Db3VudHJ5UmVmZXJlbmNlQ3VycmVuY3lJbiA9IHtcclxuICBpbnN0YWxsYXRpb25JZD86IG51bWJlcixcclxuICBjb3VudHJ5UmVmZXJlbmNlQ3VycmVuY3lJZDogbnVtYmVyLFxyXG4gIG1pbkNhc2hWYWx1ZT86IG51bWJlcixcclxuICBtYXhDYXNoVmFsdWU/OiBudW1iZXJcclxufVxyXG5cclxuZXhwb3J0IHR5cGUgSW5zdGFsbGF0aW9uQ291bnRyeVJlZmVyZW5jZUN1cnJlbmN5T3V0ID0ge1xyXG4gIGluc3RhbGxhdGlvbkNvdW50cnlSZWZlcmVuY2VDdXJyZW5jaWVzOiBJbnN0YWxsYXRpb25Db3VudHJ5UmVmZXJlbmNlQ3VycmVuY3lcclxufVxyXG5cclxuZXhwb3J0IHR5cGUgQ2FzaFZhbHVlU3VtbWFyeU91dCA9IHtcclxuICB0b3RhbDogbnVtYmVyXHJcbiAgY2FzaFZhbHVlU3VtbWFyeTogQ2FzaFZhbHVlU3VtbWFyeVtdXHJcbn1cclxuXHJcbmV4cG9ydCB0eXBlIE9wZW5pbmdUcmFuc2ZlcmVuY2VJbiA9IHtcclxuICBvcGVuaW5nSWQ6IG51bWJlclxyXG4gIGFtb3VudDogbnVtYmVyXHJcbiAgY291bnRyeVJlZmVyZW5jZUN1cnJlbmN5SWQ6IG51bWJlclxyXG4gIHRyYW5zZmVyZW5jZVR5cGVDb2RlOiBzdHJpbmdcclxufVxyXG5cclxuZXhwb3J0IHR5cGUgT3BlbmluZ1RyYW5zZmVyZW5jZU91dCA9IHtcclxuICBvcGVuaW5nVHJhbnNmZXJlbmNlOiBPcGVuaW5nVHJhbnNmZXJlbmNlXHJcbn1cclxuXHJcbmV4cG9ydCB0eXBlIFJlY2VpcHRGaWxlT3V0ID0ge1xyXG4gIHJlY2VpcHQ6IFJlY2VpcHRGaWxlXHJcbn1cclxuIl19

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}\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 SupplyEntity extends LaravelModel {\r\n  name: string\r\n  description: string\r\n  country_id: number\r\n  enabled_for_dropoff: boolean\r\n  supply_type: SupplyType\r\n  supply_packing: SupplyPacking\r\n}\r\n\r\nexport interface SupplyPacking extends LaravelModel {\r\n  value: number\r\n  weight: number\r\n  height: number\r\n  depth: number\r\n  width: number\r\n  emobile_code: string | null\r\n}\r\n\r\nexport interface SupplyType extends LaravelModel {\r\n  name: string\r\n}\r\n\r\nexport interface 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"]}
+//# 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}\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"]}

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  Installation,\r\n  Location,\r\n  LocationEmployee,\r\n  Parameter,\r\n  ParameterConfig,\r\n  ProductEntity,\r\n  SupplyEntity,\r\n  System, TDXAccountSetting,\r\n  WorkflowConfig\r\n} from './api-companies.interfaces'\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}\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}\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"]}
+//# 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  System,\r\n  TDXAccountSetting,\r\n  WorkflowConfig\r\n} from './api-companies.interfaces'\r\nimport { Supply } from './api-supplies.interfaces'\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}\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}\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: Supply[]\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"]}

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-composition.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-composition.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { ActiveLessSymfonyModel, SymfonyModel } from './api.models'\r\nimport { CustomerType } from './api-shipments.enums'\r\n\r\nexport interface ShipmentComposition extends SymfonyModel {\r\n  currencyCode: string\r\n  extraCharges: ExtraChargeComposition[]\r\n  globalProductCode: string\r\n  globalProductName: string\r\n  localProductCode: string\r\n  localProductName: string\r\n  trackingNumber: string\r\n  contentDescription: string\r\n  realWeight: number\r\n  piecesNumber: number\r\n  productSubtotal: number\r\n  productTax: number\r\n  productTotal: number\r\n  declaredValue: number\r\n  insuredValue: number\r\n  accountNumber: string\r\n  userId: number\r\n  installationId: number\r\n  companyCountryId: number\r\n  productId: number\r\n  countryReferenceCurrencyId: number\r\n  commercialExchangeRate: number\r\n  ibsExchangeRate: number\r\n  shipmentStatusId: number\r\n  shipmentAddresses: ShipmentAddresses[]\r\n  shipmentPieces: ShipmentPieces[]\r\n  shipmentCompanyCountryExtraCharges: ShipmentCompanyCountryExtraCharges[]\r\n  shipmentGsop: ShipmentGsop\r\n  additionalData: AdditionalData\r\n  transactionId: string\r\n  requiresPayment: boolean\r\n  originServiceAreaCode: string\r\n  originFacilityCode: string\r\n  destinationServiceAreaCode: string\r\n  destinationFacilityCode: string\r\n  productTaxes: string[]\r\n  isInspected: boolean\r\n  extraFields: {\r\n    [key: string]: string | number | boolean\r\n  }\r\n  shipmentContentTypeId: number\r\n  commercialInvoice: CommercialInvoice\r\n  shipmentScopeId: number\r\n  shipmentGroupId: number\r\n  product: string[]\r\n  declaredCurrency: string\r\n  insuredCurrency: string\r\n  deliveryDateTime: string\r\n  date: string\r\n  promotionCode: string\r\n  priceOverrideApproverId: number\r\n  priceOverrideReasonId: number\r\n  customs: Customs\r\n  exportReasonId: number\r\n  exportReason: string[]\r\n  shipmentBookPickup: ShipmentBookPickup\r\n  questionId: number\r\n  isInsured: boolean\r\n  itnNumber: string\r\n  einNumber: string\r\n  otherAccountNumber: string\r\n  dutiesAndTaxesAccountNumber: string\r\n  discountId: string\r\n  discountReference: string\r\n  totalPublishedValue: number\r\n  totalPartnerAccountValue: number\r\n  isMarketingConsent: boolean\r\n  isTermCondition: boolean\r\n  isDocument: boolean\r\n  isCash: boolean\r\n  isPriceOverride: boolean\r\n  isProforma: boolean\r\n  isPromotionCode: boolean\r\n  isRetailRate: boolean\r\n  isOtherOrigin: boolean\r\n  isOccurs: boolean\r\n  isDutiesAndTaxes: boolean\r\n}\r\n\r\nexport interface ExtraChargeComposition {\r\n  globalServiceCode: string\r\n  localServiceCode: string\r\n  globalServiceName: string\r\n  localServiceName: string\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  taxes: Tax[]\r\n}\r\n\r\nexport interface Tax {\r\n  code: string\r\n  percent: number\r\n  baseAmount: number\r\n  amount: number\r\n}\r\n\r\nexport interface ShipmentAddresses extends SymfonyModel {\r\n  index: number\r\n  identificationTypeId: number\r\n  identificationNumber: string\r\n  companyName: string\r\n  fullName: string\r\n  email: string\r\n  phoneCode: string\r\n  phoneNumber: string\r\n  postalCode: string\r\n  stateCode: string\r\n  countyName: string\r\n  cityName: string\r\n  addressLine1: string\r\n  addressLine2: string\r\n  addressLine3: string\r\n  countryId: number\r\n  identificationType: IdentificationTypeComposition\r\n  roleType: CustomerType\r\n}\r\n\r\nexport interface IdentificationTypeComposition extends SymfonyModel {\r\n  name: string\r\n  companyCountryId: number\r\n}\r\n\r\nexport interface ShipmentPieces extends ActiveLessSymfonyModel {\r\n  number: number\r\n  height: number\r\n  length: number\r\n  width: number\r\n  realWeight: number\r\n  volumetricWeight: number\r\n  dataIdentifier: string\r\n  trackingNumber: string\r\n  licensePlateBarCode: string\r\n  shipmentPieceCompanyCountrySupplies: ShipmentPieceCompanyCountrySupplies[]\r\n}\r\n\r\nexport interface ShipmentPieceCompanyCountrySupplies extends ActiveLessSymfonyModel {\r\n  supplyId: number\r\n  quantity: number\r\n  subtotal: number\r\n  taxBase: number\r\n  taxPercent: number\r\n  tax: number\r\n  total: number\r\n  description: string\r\n  supply: Supply\r\n}\r\n\r\nexport interface Supply extends ActiveLessSymfonyModel {\r\n  name: string\r\n  description: string\r\n  countryId: number\r\n  enabledForDropoff: boolean\r\n  supplyType: SupplyTypeComposition\r\n  supplyPacking: SupplyPackingComposition\r\n}\r\n\r\nexport interface SupplyTypeComposition extends SymfonyModel {\r\n  name: string\r\n}\r\n\r\nexport interface SupplyPackingComposition extends ActiveLessSymfonyModel {\r\n  value: number\r\n  weight: number\r\n  height: number\r\n  depth: number\r\n  width: number\r\n}\r\n\r\nexport interface CommercialInvoice extends ActiveLessSymfonyModel {\r\n  documentTypeId: number\r\n  tradingTransactionTypeId: number\r\n  documentFunctionId: number\r\n  number: string\r\n  remarks: string\r\n  items: Item[]\r\n  documentType: DocumentType\r\n  tradingTransactionType: TradingTransactionType\r\n  documentFunction: DocumentFunction\r\n}\r\n\r\nexport interface Item extends ActiveLessSymfonyModel {\r\n  description: string\r\n  quantity: number\r\n  quantityUnitId: number\r\n  subtotal: number\r\n  manufactureCountryCode: string\r\n  realWeight: number\r\n  commodityId: number\r\n  quantityUnit: QuantityUnit\r\n  manufactureCountry: ManufactureCountry\r\n  commodity: Commodity\r\n}\r\n\r\nexport interface QuantityUnit extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n}\r\n\r\nexport interface ManufactureCountry {\r\n  id: string\r\n  code: string\r\n  name: string\r\n  locationType: string[]\r\n  unit: string[]\r\n  timezone: string\r\n  hasImportService: boolean\r\n  isActive: boolean\r\n  regions: string[]\r\n  zones: string[]\r\n  isoCode: string\r\n}\r\n\r\nexport interface Commodity extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n  countryId: number\r\n}\r\n\r\nexport interface DocumentType extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n  description: string\r\n}\r\n\r\nexport interface TradingTransactionType extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n  description: string\r\n}\r\n\r\nexport interface DocumentFunction extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n}\r\n\r\nexport interface ShipmentGsop extends ActiveLessSymfonyModel {\r\n  productContentCode: string\r\n  originServiceAreaCode: string\r\n  destinationServiceAreaCode: string\r\n  internalServiceCode: string\r\n  awbBarCode: string\r\n  dhlRoutingBarCode: string\r\n}\r\n\r\nexport interface ShipmentCompanyCountryExtraCharges extends ActiveLessSymfonyModel {\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  extraChargeId: number\r\n  extraChargeCode: string\r\n}\r\n\r\nexport interface AdditionalData {\r\n  awbTypeCode: string\r\n  countryCode: string\r\n  shipmentTypeCode: string\r\n  productGlobalCode: string\r\n  productLocalCode: string\r\n  currencyCode: string\r\n  userUsername: string\r\n  locationFacilityCode: string\r\n}\r\n\r\nexport interface Customs {\r\n  criteria: Criteria\r\n  rules: Rules[]\r\n}\r\n\r\nexport interface Criteria {\r\n  origin: string\r\n  destination: string\r\n  dutiable: boolean\r\n  declaredValue: number\r\n}\r\n\r\nexport interface Rules {\r\n  id: number\r\n  level: string\r\n  attributes: Attributes[]\r\n}\r\n\r\nexport interface Attributes {\r\n  id: number\r\n  field: string\r\n  dhlCode: string\r\n  values: Values\r\n}\r\n\r\nexport interface Values {\r\n  shipment: string\r\n  customer: CustomerComposition\r\n  invoiceHeader: string\r\n  invoiceItem: string[]\r\n}\r\n\r\nexport interface CustomerComposition {\r\n  SP: string\r\n  RV: string\r\n}\r\n\r\nexport interface ShipmentBookPickup extends ActiveLessSymfonyModel {\r\n  pickupDate: string\r\n  readyByTime: string\r\n  closeTime: string\r\n  confirmationNumber: string\r\n  packageLocationId: number\r\n  remarks: string\r\n  packageLocation: PackageLocation\r\n}\r\n\r\nexport interface PackageLocation extends SymfonyModel {\r\n  name: string\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-composition.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-composition.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { ActiveLessSymfonyModel, SymfonyModel } from './api.models'\r\nimport { CustomerType } from './api-shipments.enums'\r\nimport { Supply } from './api-supplies.interfaces'\r\n\r\nexport interface ShipmentComposition extends SymfonyModel {\r\n  currencyCode: string\r\n  extraCharges: ExtraChargeComposition[]\r\n  globalProductCode: string\r\n  globalProductName: string\r\n  localProductCode: string\r\n  localProductName: string\r\n  trackingNumber: string\r\n  contentDescription: string\r\n  realWeight: number\r\n  piecesNumber: number\r\n  productSubtotal: number\r\n  productTax: number\r\n  productTotal: number\r\n  declaredValue: number\r\n  insuredValue: number\r\n  accountNumber: string\r\n  userId: number\r\n  installationId: number\r\n  companyCountryId: number\r\n  productId: number\r\n  countryReferenceCurrencyId: number\r\n  commercialExchangeRate: number\r\n  ibsExchangeRate: number\r\n  shipmentStatusId: number\r\n  shipmentAddresses: ShipmentAddresses[]\r\n  shipmentPieces: ShipmentPieces[]\r\n  shipmentCompanyCountryExtraCharges: ShipmentCompanyCountryExtraCharges[]\r\n  shipmentGsop: ShipmentGsop\r\n  additionalData: AdditionalData\r\n  transactionId: string\r\n  requiresPayment: boolean\r\n  originServiceAreaCode: string\r\n  originFacilityCode: string\r\n  destinationServiceAreaCode: string\r\n  destinationFacilityCode: string\r\n  productTaxes: string[]\r\n  isInspected: boolean\r\n  extraFields: {\r\n    [key: string]: string | number | boolean\r\n  }\r\n  shipmentContentTypeId: number\r\n  commercialInvoice: CommercialInvoice\r\n  shipmentScopeId: number\r\n  shipmentGroupId: number\r\n  product: string[]\r\n  declaredCurrency: string\r\n  insuredCurrency: string\r\n  deliveryDateTime: string\r\n  date: string\r\n  promotionCode: string\r\n  priceOverrideApproverId: number\r\n  priceOverrideReasonId: number\r\n  customs: Customs\r\n  exportReasonId: number\r\n  exportReason: string[]\r\n  shipmentBookPickup: ShipmentBookPickup\r\n  questionId: number\r\n  isInsured: boolean\r\n  itnNumber: string\r\n  einNumber: string\r\n  otherAccountNumber: string\r\n  dutiesAndTaxesAccountNumber: string\r\n  discountId: string\r\n  discountReference: string\r\n  totalPublishedValue: number\r\n  totalPartnerAccountValue: number\r\n  isMarketingConsent: boolean\r\n  isTermCondition: boolean\r\n  isDocument: boolean\r\n  isCash: boolean\r\n  isPriceOverride: boolean\r\n  isProforma: boolean\r\n  isPromotionCode: boolean\r\n  isRetailRate: boolean\r\n  isOtherOrigin: boolean\r\n  isOccurs: boolean\r\n  isDutiesAndTaxes: boolean\r\n}\r\n\r\nexport interface ExtraChargeComposition {\r\n  globalServiceCode: string\r\n  localServiceCode: string\r\n  globalServiceName: string\r\n  localServiceName: string\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  taxes: Tax[]\r\n}\r\n\r\nexport interface Tax {\r\n  code: string\r\n  percent: number\r\n  baseAmount: number\r\n  amount: number\r\n}\r\n\r\nexport interface ShipmentAddresses extends SymfonyModel {\r\n  index: number\r\n  identificationTypeId: number\r\n  identificationNumber: string\r\n  companyName: string\r\n  fullName: string\r\n  email: string\r\n  phoneCode: string\r\n  phoneNumber: string\r\n  postalCode: string\r\n  stateCode: string\r\n  countyName: string\r\n  cityName: string\r\n  addressLine1: string\r\n  addressLine2: string\r\n  addressLine3: string\r\n  countryId: number\r\n  identificationType: IdentificationTypeComposition\r\n  roleType: CustomerType\r\n}\r\n\r\nexport interface IdentificationTypeComposition extends SymfonyModel {\r\n  name: string\r\n  companyCountryId: number\r\n}\r\n\r\nexport interface ShipmentPieces extends ActiveLessSymfonyModel {\r\n  number: number\r\n  height: number\r\n  length: number\r\n  width: number\r\n  realWeight: number\r\n  volumetricWeight: number\r\n  dataIdentifier: string\r\n  trackingNumber: string\r\n  licensePlateBarCode: string\r\n  shipmentPieceCompanyCountrySupplies: ShipmentPieceCompanyCountrySupplies[]\r\n}\r\n\r\nexport interface ShipmentPieceCompanyCountrySupplies extends ActiveLessSymfonyModel {\r\n  supplyId: number\r\n  quantity: number\r\n  subtotal: number\r\n  taxBase: number\r\n  taxPercent: number\r\n  tax: number\r\n  total: number\r\n  description: string\r\n  supply: Supply\r\n}\r\n\r\nexport interface CommercialInvoice extends ActiveLessSymfonyModel {\r\n  documentTypeId: number\r\n  tradingTransactionTypeId: number\r\n  documentFunctionId: number\r\n  number: string\r\n  remarks: string\r\n  items: Item[]\r\n  documentType: DocumentType\r\n  tradingTransactionType: TradingTransactionType\r\n  documentFunction: DocumentFunction\r\n}\r\n\r\nexport interface Item extends ActiveLessSymfonyModel {\r\n  description: string\r\n  quantity: number\r\n  quantityUnitId: number\r\n  subtotal: number\r\n  manufactureCountryCode: string\r\n  realWeight: number\r\n  commodityId: number\r\n  quantityUnit: QuantityUnit\r\n  manufactureCountry: ManufactureCountry\r\n  commodity: Commodity\r\n}\r\n\r\nexport interface QuantityUnit extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n}\r\n\r\nexport interface ManufactureCountry {\r\n  id: string\r\n  code: string\r\n  name: string\r\n  locationType: string[]\r\n  unit: string[]\r\n  timezone: string\r\n  hasImportService: boolean\r\n  isActive: boolean\r\n  regions: string[]\r\n  zones: string[]\r\n  isoCode: string\r\n}\r\n\r\nexport interface Commodity extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n  countryId: number\r\n}\r\n\r\nexport interface DocumentType extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n  description: string\r\n}\r\n\r\nexport interface TradingTransactionType extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n  description: string\r\n}\r\n\r\nexport interface DocumentFunction extends SymfonyModel {\r\n  code: string\r\n  name: string\r\n}\r\n\r\nexport interface ShipmentGsop extends ActiveLessSymfonyModel {\r\n  productContentCode: string\r\n  originServiceAreaCode: string\r\n  destinationServiceAreaCode: string\r\n  internalServiceCode: string\r\n  awbBarCode: string\r\n  dhlRoutingBarCode: string\r\n}\r\n\r\nexport interface ShipmentCompanyCountryExtraCharges extends ActiveLessSymfonyModel {\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  extraChargeId: number\r\n  extraChargeCode: string\r\n}\r\n\r\nexport interface AdditionalData {\r\n  awbTypeCode: string\r\n  countryCode: string\r\n  shipmentTypeCode: string\r\n  productGlobalCode: string\r\n  productLocalCode: string\r\n  currencyCode: string\r\n  userUsername: string\r\n  locationFacilityCode: string\r\n}\r\n\r\nexport interface Customs {\r\n  criteria: Criteria\r\n  rules: Rules[]\r\n}\r\n\r\nexport interface Criteria {\r\n  origin: string\r\n  destination: string\r\n  dutiable: boolean\r\n  declaredValue: number\r\n}\r\n\r\nexport interface Rules {\r\n  id: number\r\n  level: string\r\n  attributes: Attributes[]\r\n}\r\n\r\nexport interface Attributes {\r\n  id: number\r\n  field: string\r\n  dhlCode: string\r\n  values: Values\r\n}\r\n\r\nexport interface Values {\r\n  shipment: string\r\n  customer: CustomerComposition\r\n  invoiceHeader: string\r\n  invoiceItem: string[]\r\n}\r\n\r\nexport interface CustomerComposition {\r\n  SP: string\r\n  RV: string\r\n}\r\n\r\nexport interface ShipmentBookPickup extends ActiveLessSymfonyModel {\r\n  pickupDate: string\r\n  readyByTime: string\r\n  closeTime: string\r\n  confirmationNumber: string\r\n  packageLocationId: number\r\n  remarks: string\r\n  packageLocation: PackageLocation\r\n}\r\n\r\nexport interface PackageLocation extends SymfonyModel {\r\n  name: string\r\n}\r\n"]}