@experteam-mx/ngx-services 18.5.6 → 18.5.8

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

@@ -0,0 +1,194 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiInventoriesService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the Inventories API from the environment configurations.
+     *
+     * @return {string} The URL of the Inventories API.
+     */
+    get url() {
+        return this.environments.apiInventoriesUrl ?? '';
+    }
+    /**
+     * Retrieves a list of checkpoints based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the checkpoints.
+     * @returns {Observable<CheckpointsOut>} The list of checkpoints.
+     */
+    getCheckpoints(params) {
+        return this.http.get(`${this.url}/checkpoints`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of checkpoint event reasons based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the checkpoint event reasons.
+     * @returns {Observable<CheckpointEventReasonsOut>} The list of checkpoint event reasons.
+     */
+    getCheckpointEventReasons(params) {
+        return this.http.get(`${this.url}/checkpoint-event-reasons`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of incidents based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the incidents.
+     * @returns {Observable<IncidentsOut>} An observable that emits the list of incidents.
+     */
+    getIncidents(params) {
+        return this.http.get(`${this.url}/incidents`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the incident details based on the provided incident ID.
+     *
+     * @param {number} id - The identifier of the incident record to get detail.
+     * @return {Observable<IncidentOut>} An observable that emits the detail incident data.
+     */
+    getIncident(id) {
+        return this.http.get(`${this.url}/incidents/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new incident.
+     *
+     * @param {IncidentIn} body - The data for the new incident.
+     * @returns {Observable<IncidentOut>} An observable the created incident detail.
+     */
+    postIncident(body) {
+        return this.http.post(`${this.url}/incidents`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing incident.
+     *
+     * @param {number} id - The identifier of the incident record to update.
+     * @param {IncidentIn} body - The incident data to be updated.
+     * @returns {Observable<IncidentOut>} An observable detail of the updated incident.
+     */
+    putIncident(id, body) {
+        return this.http.put(`${this.url}/incidents/${id}`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Delete an existing incident.
+     *
+     * @param {number} id - The unique identifier of the incident to be deleted.
+     * @returns {Observable<IncidentOut>} An observable that emits the result of the delete incident.
+     */
+    deleteIncident(id) {
+        return this.http.delete(`${this.url}/incidents/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of incident reasons based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the incident reasons.
+     * @returns {Observable<IncidentReasonsOut>} An observable that emits the list of incident reasons.
+     */
+    getIncidentReasons(params) {
+        return this.http.get(`${this.url}/incident-reasons`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the incident reason details based on the provided incident reason ID.
+     *
+     * @param {number} id - The identifier of the incident reason record to get detail.
+     * @return {Observable<IncidentReasonOut>} An observable that emits the detail incident reason data.
+     */
+    getIncidentReason(id) {
+        return this.http.get(`${this.url}/incident-reasons/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new incident reason.
+     *
+     * @param {IncidentReasonIn} body - The data for the new incident reason.
+     * @returns {Observable<IncidentReasonOut>} An observable the created incident reason detail.
+     */
+    postIncidentReason(body) {
+        return this.http.post(`${this.url}/incident-reasons`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing incident reason.
+     *
+     * @param {number} id - The identifier of the incident reason record to update.
+     * @param {IncidentIn} body - The incident reason data to be updated.
+     * @returns {Observable<IncidentReasonOut>} An observable detail of the updated incident reason.
+     */
+    putIncidentReason(id, body) {
+        return this.http.put(`${this.url}/incident-reasons/${id}`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Delete an existing incident reason.
+     *
+     * @param {number} id - The unique identifier of the incident reason to be deleted.
+     * @returns {Observable<IncidentReasonOut>} An observable that emits the result of the delete incident reason.
+     */
+    deleteIncidentReason(id) {
+        return this.http.delete(`${this.url}/incident-reasons/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of incident reason complements based on query parameters.
+     *
+     * @param {QueryParams} params - Query parameters for filtering the incident reason complements.
+     * @returns {Observable<IncidentReasonComplementsOut>} An observable that emits the list of incident reason complements.
+     */
+    getIncidentReasonComplements(params) {
+        return this.http.get(`${this.url}/incident-reason-complements`, {
+            params
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Creates a new incident reason complement.
+     *
+     * @param {IncidentReasonIn} body - The data for the new incident reason complement.
+     * @returns {Observable<IncidentReasonComplementOut>} An observable the created incident reason complement detail.
+     */
+    postIncidentReasonComplement(body) {
+        return this.http.post(`${this.url}/incident-reason-complements`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing incident reason complement.
+     *
+     * @param {number} id - The identifier of the incident reason complement record to update.
+     * @param {IncidentIn} body - The incident reason complement data to be updated.
+     * @returns {Observable<IncidentReasonComplementOut>} An observable detail of the updated incident reason complement.
+     */
+    putIncidentReasonComplement(id, body) {
+        return this.http.put(`${this.url}/incident-reason-complements/${id}`, body).pipe(map(({ data }) => data));
+    }
+    /**
+     * Delete an existing incident reason complement.
+     *
+     * @param {number} id - The unique identifier of the incident reason complement to be deleted.
+     * @returns {Observable<IncidentReasonComplementOut>} An observable that emits the result of the delete incident reason complement.
+     */
+    deleteIncidentReasonComplement(id) {
+        return this.http.delete(`${this.url}/incident-reason-complements/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInventoriesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInventoriesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInventoriesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-inventories.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-inventories.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport { map, Observable } from 'rxjs'\r\nimport { CheckpointEventReasonsOut, CheckpointsOut, IncidentIn, IncidentOut, IncidentReasonComplementIn, IncidentReasonComplementOut, IncidentReasonComplementsOut, IncidentReasonIn, IncidentReasonOut, IncidentReasonsOut, IncidentsOut } from './models/api-inventories.types'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInventoriesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the URL for the Inventories API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the Inventories API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInventoriesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of checkpoints based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the checkpoints.\r\n   * @returns {Observable<CheckpointsOut>} The list of checkpoints.\r\n   */\r\n  getCheckpoints (params: QueryParams): Observable<CheckpointsOut> {\r\n    return this.http.get<ApiSuccess<CheckpointsOut>>(`${this.url}/checkpoints`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of checkpoint event reasons based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the checkpoint event reasons.\r\n   * @returns {Observable<CheckpointEventReasonsOut>} The list of checkpoint event reasons.\r\n   */\r\n  getCheckpointEventReasons (params: QueryParams): Observable<CheckpointEventReasonsOut> {\r\n    return this.http.get<ApiSuccess<CheckpointEventReasonsOut>>(`${this.url}/checkpoint-event-reasons`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of incidents based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the incidents.\r\n   * @returns {Observable<IncidentsOut>} An observable that emits the list of incidents.\r\n   */\r\n  getIncidents (params: QueryParams): Observable<IncidentsOut> {\r\n    return this.http.get<ApiSuccess<IncidentsOut>>(`${this.url}/incidents`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the incident details based on the provided incident ID.\r\n   *\r\n   * @param {number} id - The identifier of the incident record to get detail.\r\n   * @return {Observable<IncidentOut>} An observable that emits the detail incident data.\r\n   */\r\n  getIncident (id: Number): Observable<IncidentOut> {\r\n    return this.http.get<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new incident.\r\n   *\r\n   * @param {IncidentIn} body - The data for the new incident.\r\n   * @returns {Observable<IncidentOut>} An observable the created incident detail.\r\n   */\r\n  postIncident (body: IncidentIn): Observable<IncidentOut> {\r\n    return this.http.post<ApiSuccess<IncidentOut>>(`${this.url}/incidents`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing incident.\r\n   *\r\n   * @param {number} id - The identifier of the incident record to update.\r\n   * @param {IncidentIn} body - The incident data to be updated.\r\n   * @returns {Observable<IncidentOut>} An observable detail of the updated incident.\r\n   */\r\n  putIncident (id: Number, body: IncidentIn): Observable<IncidentOut> {\r\n    return this.http.put<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing incident.\r\n   *\r\n   * @param {number} id - The unique identifier of the incident to be deleted.\r\n   * @returns {Observable<IncidentOut>} An observable that emits the result of the delete incident.\r\n   */\r\n  deleteIncident (id: Number): Observable<IncidentOut> {\r\n    return this.http.delete<ApiSuccess<IncidentOut>>(`${this.url}/incidents/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of incident reasons based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the incident reasons.\r\n   * @returns {Observable<IncidentReasonsOut>} An observable that emits the list of incident reasons.\r\n   */\r\n  getIncidentReasons (params: QueryParams): Observable<IncidentReasonsOut> {\r\n    return this.http.get<ApiSuccess<IncidentReasonsOut>>(`${this.url}/incident-reasons`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the incident reason details based on the provided incident reason ID.\r\n   *\r\n   * @param {number} id - The identifier of the incident reason record to get detail.\r\n   * @return {Observable<IncidentReasonOut>} An observable that emits the detail incident reason data.\r\n   */\r\n  getIncidentReason (id: Number): Observable<IncidentReasonOut> {\r\n    return this.http.get<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new incident reason.\r\n   *\r\n   * @param {IncidentReasonIn} body - The data for the new incident reason.\r\n   * @returns {Observable<IncidentReasonOut>} An observable the created incident reason detail.\r\n   */\r\n  postIncidentReason (body: IncidentReasonIn): Observable<IncidentReasonOut> {\r\n    return this.http.post<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing incident reason.\r\n   *\r\n   * @param {number} id - The identifier of the incident reason record to update.\r\n   * @param {IncidentIn} body - The incident reason data to be updated.\r\n   * @returns {Observable<IncidentReasonOut>} An observable detail of the updated incident reason.\r\n   */\r\n  putIncidentReason (id: Number, body: IncidentReasonIn): Observable<IncidentReasonOut> {\r\n    return this.http.put<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing incident reason.\r\n   *\r\n   * @param {number} id - The unique identifier of the incident reason to be deleted.\r\n   * @returns {Observable<IncidentReasonOut>} An observable that emits the result of the delete incident reason.\r\n   */\r\n  deleteIncidentReason (id: Number): Observable<IncidentReasonOut> {\r\n    return this.http.delete<ApiSuccess<IncidentReasonOut>>(`${this.url}/incident-reasons/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of incident reason complements based on query parameters.\r\n   *\r\n   * @param {QueryParams} params - Query parameters for filtering the incident reason complements.\r\n   * @returns {Observable<IncidentReasonComplementsOut>} An observable that emits the list of incident reason complements.\r\n   */\r\n  getIncidentReasonComplements (params: QueryParams): Observable<IncidentReasonComplementsOut> {\r\n    return this.http.get<ApiSuccess<IncidentReasonComplementsOut>>(`${this.url}/incident-reason-complements`, {\r\n      params\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Creates a new incident reason complement.\r\n   *\r\n   * @param {IncidentReasonIn} body - The data for the new incident reason complement.\r\n   * @returns {Observable<IncidentReasonComplementOut>} An observable the created incident reason complement detail.\r\n   */\r\n  postIncidentReasonComplement (body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut> {\r\n    return this.http.post<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing incident reason complement.\r\n   *\r\n   * @param {number} id - The identifier of the incident reason complement record to update.\r\n   * @param {IncidentIn} body - The incident reason complement data to be updated.\r\n   * @returns {Observable<IncidentReasonComplementOut>} An observable detail of the updated incident reason complement.\r\n   */\r\n  putIncidentReasonComplement (id: Number, body: IncidentReasonComplementIn): Observable<IncidentReasonComplementOut> {\r\n    return this.http.put<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements/${id}`,\r\n      body\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing incident reason complement.\r\n   *\r\n   * @param {number} id - The unique identifier of the incident reason complement to be deleted.\r\n   * @returns {Observable<IncidentReasonComplementOut>} An observable that emits the result of the delete incident reason complement.\r\n   */\r\n  deleteIncidentReasonComplement (id: Number): Observable<IncidentReasonComplementOut> {\r\n    return this.http.delete<ApiSuccess<IncidentReasonComplementOut>>(`${this.url}/incident-reason-complements/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

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

@@ -129,6 +129,160 @@ export class ApiInvoicesService {
         return this.http.get(`${this.url}/operation/print/document/${documentId}`)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Fetches all country payment types.
+     *
+     * @param {QueryParams} params - Query parameters to filter or customize the request.
+     * @return {Observable<CountryPaymentTypesOut>} An observable emitting the country payment types fetched from the server.
+     */
+    getCountryPaymentTypes(params) {
+        return this.http.get(`${this.url}/country-payment-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing country payment type.
+     *
+     * @param {number} id - The ID of the country payment type to update.
+     * @param {CountryPaymentTypeIn} body - The updated data for the country payment type.
+     * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the update operation.
+     */
+    putCountryPaymentType(id, body) {
+        return this.http.put(`${this.url}/country-payment-types/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Delete an existing country payment type.
+     *
+     * @param {number} id - The unique identifier of the country payment type to be deleted.
+     * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the delete operation.
+     */
+    deleteCountryPaymentType(id) {
+        return this.http.delete(`${this.url}/country-payment-types/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Create a new country payment type resource.
+     *
+     * @param {CountryPaymentTypeIn} body - The input parameters required for create a new country payment type.
+     * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of create operation.
+     */
+    postCountryPaymentType(body) {
+        return this.http.post(`${this.url}/country-payment-types`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves and returns a country payment type for a given ID.
+     *
+     * @param {number} id - The ID of the country payment type.
+     * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of show operation.
+     */
+    getCountryPaymentType(id) {
+        return this.http.get(`${this.url}/country-payment-types/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches all country payment type fields.
+     *
+     * @param {QueryParams} params - Query parameters to filter or customize the request.
+     * @return {Observable<CountryPaymentTypeFieldsOut>} An observable emitting the country payment type fields fetched from the server.
+     */
+    getCountryPaymentTypeFields(params) {
+        return this.http.get(`${this.url}/country-payment-type-fields`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Create a new country payment type field resource.
+     *
+     * @param {CountryPaymentTypeFieldIn} body - The input parameters required for create a new country payment type field.
+     * @return {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of create operation.
+     */
+    postCountryPaymentTypeField(body) {
+        return this.http.post(`${this.url}/country-payment-type-fields`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing country payment type field.
+     *
+     * @param {number} id - The ID of the country payment type field to update.
+     * @param {CountryPaymentTypeFieldIn} body - The updated data for the country payment type field.
+     * @returns {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of the update operation.
+     */
+    putCountryPaymentTypeField(id, body) {
+        return this.http.put(`${this.url}/country-payment-type-fields/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches all payment types.
+     *
+     * @param {QueryParams} params - Query parameters to filter or customize the request.
+     * @return {Observable<PaymentTypesOut>} An observable emitting the payment types fetched from the server.
+     */
+    getPaymentTypes(params) {
+        return this.http.get(`${this.url}/payment-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches all payment type fields card.
+     *
+     * @param {QueryParams} params - Query parameters to filter or customize the request.
+     * @return {Observable<PaymentTypeFieldCardTypesOut>} An observable emitting the payment type fields card fetched from the server.
+     */
+    getPaymentTypeFieldCardTypes(params) {
+        return this.http.get(`${this.url}/payment-type-field-card-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Create a new payment type field card resource.
+     *
+     * @param {PaymentTypeFieldCardTypeIn} body - The input parameters required for create a new payment type field card.
+     * @return {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of create operation.
+     */
+    postCountryPaymentTypeFieldCardType(body) {
+        return this.http.post(`${this.url}/payment-type-field-card-types`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing payment type field card.
+     *
+     * @param {number} id - The ID of the payment type field card to update.
+     * @param {PaymentTypeFieldCardTypeIn} body - The updated data for the payment type field card.
+     * @returns {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of the update operation.
+     */
+    putCountryPaymentTypeFieldCardType(id, body) {
+        return this.http.put(`${this.url}/payment-type-field-card-types/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches all payment type fields accounts.
+     *
+     * @param {QueryParams} params - Query parameters to filter or customize the request.
+     * @return {Observable<PaymentTypeFieldAccountsOut>} An observable emitting the payment type fields accounts fetched from the server.
+     */
+    getPaymentTypeFieldAccounts(params) {
+        return this.http.get(`${this.url}/payment-type-field-accounts`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Create a new payment type field account resource.
+     *
+     * @param {PaymentTypeFieldAccountIn} body - The input parameters required for create a new payment type field account.
+     * @return {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of create operation.
+     */
+    postCountryPaymentTypeFieldAccount(body) {
+        return this.http.post(`${this.url}/payment-type-field-accounts`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Updates an existing payment type field account.
+     *
+     * @param {number} id - The ID of the payment type field account to update.
+     * @param {PaymentTypeFieldAccountIn} body - The updated data for the payment type field account.
+     * @returns {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of the update operation.
+     */
+    putCountryPaymentTypeFieldAccount(id, body) {
+        return this.http.put(`${this.url}/payment-type-field-accounts/${id}`, body)
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInvoicesService, 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: ApiInvoicesService, providedIn: 'root' });
 }
@@ -141,4 +295,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-invoices.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-invoices.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EAAE,GAAG,EAAc,MAAM,MAAM,CAAA;;;AAuBtC,MAAM,OAAO,kBAAkB;IAEJ;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,cAAc,IAAI,EAAE,CAAA;IAC/C,CAAC;IAED;;;;;OAKG;IACH,qBAAqB,CAAE,IAAyB;QAC9C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAmC,GAAG,IAAI,CAAC,GAAG,qBAAqB,EAAE,IAAI,CAAC;aAC5F,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAE,EAAU;QACnC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAwC,GAAG,IAAI,CAAC,GAAG,uCAAuC,EAAE,EAAE,CAAC;aAChH,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;;OAMG;IACH,2BAA2B,CAAE,IAA+B;QAC1D,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAyC,GAAG,IAAI,CAAC,GAAG,4BAA4B,EAAE,IAAI,CAAC;aACzG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;;OAMG;IACH,2BAA2B,CAAE,IAA4B;QACvD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiB,GAAG,IAAI,CAAC,GAAG,4BAA4B,EAAE,IAAI,CAAC;aACjF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,0BAA0B,CAAE,EAAE,SAAS,EAAE,GAAG,IAAI,EAA4B;QAC1E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiB,GAAG,IAAI,CAAC,GAAG,6BAA6B,SAAS,EAAE,EAAE,IAAI,CAAC;aAC7F,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAE,MAAmB;QACnC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA+B,GAAG,IAAI,CAAC,GAAG,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAAC;aACzF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,wBAAwB,CAAE,MAAmB;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAuC,GAAG,IAAI,CAAC,GAAG,kCAAkC,EAAE,EAAE,MAAM,EAAE,CAAC;aAClH,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAE,MAAmB;QAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAA2B,GAAG,IAAI,CAAC,GAAG,YAAY,EAAE,EAAE,MAAM,EAAE,CAAC;aAChF,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,6BAA6B,CAAE,MAAmC;QAChE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA2C,GAAG,IAAI,CAAC,GAAG,8BAA8B,EAAE,MAAM,CAAC;aAC/G,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,oCAAoC,CAAE,MAAmC;QACvE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAA2C,GAAG,IAAI,CAAC,GAAG,sCAAsC,EAAE,MAAM,CAAC;aACvH,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAE,UAAkB;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAwC,GAAG,IAAI,CAAC,GAAG,6BAA6B,UAAU,EAAE,CAAC;aAC9G,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,CAAC;wGAxIU,kBAAkB,kBAEnB,KAAK;4GAFJ,kBAAkB,cAFjB,MAAM;;4FAEP,kBAAkB;kBAH9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAGI,MAAM;2BAAC,KAAK","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\nimport { map, Observable } from 'rxjs'\r\nimport { Environment } from '../ngx-services.models'\r\nimport {\r\n  CancelPaymentReceiptIn,\r\n  CustomerDocumentTypesOut,\r\n  CustomersOut,\r\n  CustomerTypesOut,\r\n  InvoiceTypeCustomParamsIn,\r\n  OperationAccountPaymentIn,\r\n  OperationAccountPaymentOut,\r\n  OperationCancelBillingIn,\r\n  OperationDocumentIn,\r\n  OperationDocumentOut,\r\n  OperationPrintDocumentOut,\r\n  OperationShipmentExternalIn,\r\n  OperationShipmentExternalOut,\r\n  PrintCollectionReceiptOut\r\n} from './models/api-invoices.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInvoicesService {\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 API URL for invoices from the environments configuration.\r\n   *\r\n   * @return {string} The API URL for invoices.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInvoicesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Sends an operation document to the server and processes the response.\r\n   *\r\n   * @param {OperationDocumentIn} body - The input data for the operation document.\r\n   * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.\r\n   */\r\n  postOperationDocument (body: OperationDocumentIn): Observable<OperationDocumentOut> {\r\n    return this.http.post<ApiSuccess<OperationDocumentOut>>(`${this.url}/operation/document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches and returns the collection receipt data for a given collection ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.\r\n   * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.\r\n   */\r\n  getPrintCollectionReceipt (id: number): Observable<PrintCollectionReceiptOut> {\r\n    return this.http.get<ApiSuccess<PrintCollectionReceiptOut>>(`${this.url}/operation/print/collection-receipt/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Handles the account payment operation by sending a POST request to the specified endpoint.\r\n   * Processes the response and returns the operation data.\r\n   *\r\n   * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.\r\n   * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.\r\n   */\r\n  postOperationAccountPayment (body: OperationAccountPaymentIn): Observable<OperationAccountPaymentOut> {\r\n    return this.http.post<ApiSuccess<OperationAccountPaymentOut>>(`${this.url}/operation/account-payment`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels a payment receipt based on the provided input.\r\n   * This method sends a POST request to cancel a document.\r\n   *\r\n   * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.\r\n   * @return An Observable representing the result of the cancellation. Emits an empty object on success.\r\n   */\r\n  postOperationCancelDocument (body: CancelPaymentReceiptIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels an invoice based on the provided invoice ID and additional parameters.\r\n   *\r\n   * @param {Object} parameters - The parameters required to cancel the invoice, encapsulated in a CancelBillingIn object.\r\n   * @return {Observable<Object>} An observable that emits the response of the cancellation operation.\r\n   */\r\n  postOperationCancelBilling ({ invoiceId, ...body }: OperationCancelBillingIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-billing/${invoiceId}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of customer types from the server.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.\r\n   */\r\n  getCustomerTypes (params: QueryParams): Observable<CustomerTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerTypesOut>>(`${this.url}/customer-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves document types specific to a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters containing country-specific information.\r\n   * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.\r\n   */\r\n  getCustomerDocumentTypes (params: QueryParams): Observable<CustomerDocumentTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerDocumentTypesOut>>(`${this.url}/customer-country-document-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches customer invoice details filtered by a custom invoice type.\r\n   *\r\n   * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.\r\n   * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.\r\n   */\r\n  getCustomers (params: QueryParams): Observable<CustomersOut> {\r\n    return this.http.get<ApiSuccess<CustomersOut>>(`${this.url}/customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update an external shipment operation.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.\r\n   */\r\n  postOperationShipmentExternal (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Processes an external payment operation for a shipment.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.\r\n   */\r\n  postOperationShipmentExternalPayment (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external/payment`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns billing operation print details for a given document ID.\r\n   *\r\n   * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.\r\n   * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.\r\n   */\r\n  getOperationPrintDocument (documentId: number): Observable<OperationPrintDocumentOut> {\r\n    return this.http.get<ApiSuccess<OperationPrintDocumentOut>>(`${this.url}/operation/print/document/${documentId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-invoices.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-invoices.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\nimport { map, Observable } from 'rxjs'\r\nimport { Environment } from '../ngx-services.models'\r\nimport {\r\n  CancelPaymentReceiptIn,\r\n  CountryPaymentTypeIn,\r\n  CountryPaymentTypesOut,\r\n  CountryPaymentTypeOut,\r\n  CountryPaymentTypeFieldIn,\r\n  CountryPaymentTypeFieldOut,\r\n  CountryPaymentTypeFieldsOut,\r\n  CustomerDocumentTypesOut,\r\n  CustomersOut,\r\n  CustomerTypesOut,\r\n  InvoiceTypeCustomParamsIn,\r\n  OperationAccountPaymentIn,\r\n  OperationAccountPaymentOut,\r\n  OperationCancelBillingIn,\r\n  OperationDocumentIn,\r\n  OperationDocumentOut,\r\n  OperationPrintDocumentOut,\r\n  OperationShipmentExternalIn,\r\n  OperationShipmentExternalOut,\r\n  PaymentTypeFieldAccountIn,\r\n  PaymentTypeFieldAccountOut,\r\n  PaymentTypeFieldAccountsOut,\r\n  PaymentTypeFieldCardTypeIn,\r\n  PaymentTypeFieldCardTypeOut,\r\n  PaymentTypeFieldCardTypesOut,\r\n  PrintCollectionReceiptOut,\r\n  PaymentTypesOut,\r\n} from './models/api-invoices.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInvoicesService {\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 API URL for invoices from the environments configuration.\r\n   *\r\n   * @return {string} The API URL for invoices.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInvoicesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Sends an operation document to the server and processes the response.\r\n   *\r\n   * @param {OperationDocumentIn} body - The input data for the operation document.\r\n   * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.\r\n   */\r\n  postOperationDocument (body: OperationDocumentIn): Observable<OperationDocumentOut> {\r\n    return this.http.post<ApiSuccess<OperationDocumentOut>>(`${this.url}/operation/document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches and returns the collection receipt data for a given collection ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.\r\n   * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.\r\n   */\r\n  getPrintCollectionReceipt (id: number): Observable<PrintCollectionReceiptOut> {\r\n    return this.http.get<ApiSuccess<PrintCollectionReceiptOut>>(`${this.url}/operation/print/collection-receipt/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Handles the account payment operation by sending a POST request to the specified endpoint.\r\n   * Processes the response and returns the operation data.\r\n   *\r\n   * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.\r\n   * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.\r\n   */\r\n  postOperationAccountPayment (body: OperationAccountPaymentIn): Observable<OperationAccountPaymentOut> {\r\n    return this.http.post<ApiSuccess<OperationAccountPaymentOut>>(`${this.url}/operation/account-payment`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels a payment receipt based on the provided input.\r\n   * This method sends a POST request to cancel a document.\r\n   *\r\n   * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.\r\n   * @return An Observable representing the result of the cancellation. Emits an empty object on success.\r\n   */\r\n  postOperationCancelDocument (body: CancelPaymentReceiptIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels an invoice based on the provided invoice ID and additional parameters.\r\n   *\r\n   * @param {Object} parameters - The parameters required to cancel the invoice, encapsulated in a CancelBillingIn object.\r\n   * @return {Observable<Object>} An observable that emits the response of the cancellation operation.\r\n   */\r\n  postOperationCancelBilling ({ invoiceId, ...body }: OperationCancelBillingIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-billing/${invoiceId}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of customer types from the server.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.\r\n   */\r\n  getCustomerTypes (params: QueryParams): Observable<CustomerTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerTypesOut>>(`${this.url}/customer-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves document types specific to a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters containing country-specific information.\r\n   * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.\r\n   */\r\n  getCustomerDocumentTypes (params: QueryParams): Observable<CustomerDocumentTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerDocumentTypesOut>>(`${this.url}/customer-country-document-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches customer invoice details filtered by a custom invoice type.\r\n   *\r\n   * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.\r\n   * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.\r\n   */\r\n  getCustomers (params: QueryParams): Observable<CustomersOut> {\r\n    return this.http.get<ApiSuccess<CustomersOut>>(`${this.url}/customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update an external shipment operation.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.\r\n   */\r\n  postOperationShipmentExternal (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Processes an external payment operation for a shipment.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.\r\n   */\r\n  postOperationShipmentExternalPayment (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external/payment`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns billing operation print details for a given document ID.\r\n   *\r\n   * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.\r\n   * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.\r\n   */\r\n  getOperationPrintDocument (documentId: number): Observable<OperationPrintDocumentOut> {\r\n    return this.http.get<ApiSuccess<OperationPrintDocumentOut>>(`${this.url}/operation/print/document/${documentId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all country payment types.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CountryPaymentTypesOut>} An observable emitting the country payment types fetched from the server.\r\n   */\r\n  getCountryPaymentTypes (params: QueryParams): Observable<CountryPaymentTypesOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypesOut>>(`${this.url}/country-payment-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing country payment type.\r\n   *\r\n   * @param {number} id - The ID of the country payment type to update.\r\n   * @param {CountryPaymentTypeIn} body - The updated data for the country payment type.\r\n   * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentType (id: number, body: CountryPaymentTypeIn): Observable<CountryPaymentTypeOut> {\r\n    return this.http.put<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Delete an existing country payment type.\r\n   *\r\n   * @param {number} id - The unique identifier of the country payment type to be deleted.\r\n   * @returns {Observable<CountryPaymentTypeOut>} An observable that emits the result of the delete operation.\r\n   */\r\n  deleteCountryPaymentType (id: number): Observable<CountryPaymentTypeOut> {\r\n    return this.http.delete<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new country payment type resource.\r\n   *\r\n   * @param {CountryPaymentTypeIn} body - The input parameters required for create a new country payment type.\r\n   * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentType (body: CountryPaymentTypeIn): Observable<CountryPaymentTypeOut> {\r\n    return this.http.post<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns a country payment type for a given ID.\r\n   *\r\n   * @param {number} id - The ID of the country payment type.\r\n   * @return {Observable<CountryPaymentTypeOut>} An observable that emits the result of show operation.\r\n   */\r\n  getCountryPaymentType (id: number): Observable<CountryPaymentTypeOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypeOut>>(`${this.url}/country-payment-types/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all country payment type fields.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CountryPaymentTypeFieldsOut>} An observable emitting the country payment type fields fetched from the server.\r\n   */\r\n  getCountryPaymentTypeFields (params: QueryParams): Observable<CountryPaymentTypeFieldsOut> {\r\n    return this.http.get<ApiSuccess<CountryPaymentTypeFieldsOut>>(`${this.url}/country-payment-type-fields`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new country payment type field resource.\r\n   *\r\n   * @param {CountryPaymentTypeFieldIn} body - The input parameters required for create a new country payment type field.\r\n   * @return {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeField (body: CountryPaymentTypeFieldIn): Observable<CountryPaymentTypeFieldOut> {\r\n    return this.http.post<ApiSuccess<CountryPaymentTypeFieldOut>>(`${this.url}/country-payment-type-fields`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing country payment type field.\r\n   *\r\n   * @param {number} id - The ID of the country payment type field to update.\r\n   * @param {CountryPaymentTypeFieldIn} body - The updated data for the country payment type field.\r\n   * @returns {Observable<CountryPaymentTypeFieldOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeField (id: number, body: CountryPaymentTypeFieldIn): Observable<CountryPaymentTypeFieldOut> {\r\n    return this.http.put<ApiSuccess<CountryPaymentTypeFieldOut>>(`${this.url}/country-payment-type-fields/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment types.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypesOut>} An observable emitting the payment types fetched from the server.\r\n   */\r\n  getPaymentTypes (params: QueryParams): Observable<PaymentTypesOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypesOut>>(`${this.url}/payment-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment type fields card.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypeFieldCardTypesOut>} An observable emitting the payment type fields card fetched from the server.\r\n   */\r\n  getPaymentTypeFieldCardTypes (params: QueryParams): Observable<PaymentTypeFieldCardTypesOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypeFieldCardTypesOut>>(`${this.url}/payment-type-field-card-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new payment type field card resource.\r\n   *\r\n   * @param {PaymentTypeFieldCardTypeIn} body - The input parameters required for create a new payment type field card.\r\n   * @return {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeFieldCardType (body: PaymentTypeFieldCardTypeIn): Observable<PaymentTypeFieldCardTypeOut> {\r\n    return this.http.post<ApiSuccess<PaymentTypeFieldCardTypeOut>>(`${this.url}/payment-type-field-card-types`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing payment type field card.\r\n   *\r\n   * @param {number} id - The ID of the payment type field card to update.\r\n   * @param {PaymentTypeFieldCardTypeIn} body - The updated data for the payment type field card.\r\n   * @returns {Observable<PaymentTypeFieldCardTypeOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeFieldCardType (id: number, body: PaymentTypeFieldCardTypeIn): Observable<PaymentTypeFieldCardTypeOut> {\r\n    return this.http.put<ApiSuccess<PaymentTypeFieldCardTypeOut>>(`${this.url}/payment-type-field-card-types/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches all payment type fields accounts.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<PaymentTypeFieldAccountsOut>} An observable emitting the payment type fields accounts fetched from the server.\r\n   */\r\n  getPaymentTypeFieldAccounts (params: QueryParams): Observable<PaymentTypeFieldAccountsOut> {\r\n    return this.http.get<ApiSuccess<PaymentTypeFieldAccountsOut>>(`${this.url}/payment-type-field-accounts`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Create a new payment type field account resource.\r\n   *\r\n   * @param {PaymentTypeFieldAccountIn} body - The input parameters required for create a new payment type field account.\r\n   * @return {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of create operation.\r\n   */\r\n  postCountryPaymentTypeFieldAccount (body: PaymentTypeFieldAccountIn): Observable<PaymentTypeFieldAccountOut> {\r\n    return this.http.post<ApiSuccess<PaymentTypeFieldAccountOut>>(`${this.url}/payment-type-field-accounts`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Updates an existing payment type field account.\r\n   *\r\n   * @param {number} id - The ID of the payment type field account to update.\r\n   * @param {PaymentTypeFieldAccountIn} body - The updated data for the payment type field account.\r\n   * @returns {Observable<PaymentTypeFieldAccountOut>} An observable that emits the result of the update operation.\r\n   */\r\n  putCountryPaymentTypeFieldAccount (id: number, body: PaymentTypeFieldAccountIn): Observable<PaymentTypeFieldAccountOut> {\r\n    return this.http.put<ApiSuccess<PaymentTypeFieldAccountOut>>(`${this.url}/payment-type-field-accounts/${id}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

package/esm2022/lib/apis/models/api-inventories.enum.mjs

@@ -0,0 +1,22 @@
+export var Event;
+(function (Event) {
+    Event["damage"] = "damage";
+    Event["lost"] = "lost";
+    Event["rejected"] = "rejected";
+    Event["return"] = "return ";
+})(Event || (Event = {}));
+export var DefaultValueType;
+(function (DefaultValueType) {
+    DefaultValueType["payment_type"] = "payment_type";
+    DefaultValueType["currency_code"] = "currency_code";
+    DefaultValueType["destination"] = "destination";
+    DefaultValueType["payment_amount"] = "payment_amount";
+})(DefaultValueType || (DefaultValueType = {}));
+export var AlphaNumeric;
+(function (AlphaNumeric) {
+    AlphaNumeric["alpha_numeric"] = "alpha_numeric";
+    AlphaNumeric["numeric"] = "numeric";
+    AlphaNumeric["alphabetic"] = "alphabetic";
+    AlphaNumeric["amount"] = "amount";
+})(AlphaNumeric || (AlphaNumeric = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWludmVudG9yaWVzLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9leHBlcnRlYW0tbXgvbmd4LXNlcnZpY2VzL3NyYy9saWIvYXBpcy9tb2RlbHMvYXBpLWludmVudG9yaWVzLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksS0FLWDtBQUxELFdBQVksS0FBSztJQUNmLDBCQUFpQixDQUFBO0lBQ2pCLHNCQUFhLENBQUE7SUFDYiw4QkFBcUIsQ0FBQTtJQUNyQiwyQkFBa0IsQ0FBQTtBQUNwQixDQUFDLEVBTFcsS0FBSyxLQUFMLEtBQUssUUFLaEI7QUFFRCxNQUFNLENBQU4sSUFBWSxnQkFLWDtBQUxELFdBQVksZ0JBQWdCO0lBQzFCLGlEQUE2QixDQUFBO0lBQzdCLG1EQUErQixDQUFBO0lBQy9CLCtDQUEyQixDQUFBO0lBQzNCLHFEQUFpQyxDQUFBO0FBQ25DLENBQUMsRUFMVyxnQkFBZ0IsS0FBaEIsZ0JBQWdCLFFBSzNCO0FBRUQsTUFBTSxDQUFOLElBQVksWUFLWDtBQUxELFdBQVksWUFBWTtJQUN0QiwrQ0FBK0IsQ0FBQTtJQUMvQixtQ0FBbUIsQ0FBQTtJQUNuQix5Q0FBeUIsQ0FBQTtJQUN6QixpQ0FBaUIsQ0FBQTtBQUNuQixDQUFDLEVBTFcsWUFBWSxLQUFaLFlBQVksUUFLdkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBFdmVudCB7XHJcbiAgZGFtYWdlID0gJ2RhbWFnZScsXHJcbiAgbG9zdCA9ICdsb3N0JyxcclxuICByZWplY3RlZCA9ICdyZWplY3RlZCcsXHJcbiAgcmV0dXJuID0gJ3JldHVybiAnXHJcbn1cclxuXHJcbmV4cG9ydCBlbnVtIERlZmF1bHRWYWx1ZVR5cGUge1xyXG4gIHBheW1lbnRfdHlwZSA9ICdwYXltZW50X3R5cGUnLFxyXG4gIGN1cnJlbmN5X2NvZGUgPSAnY3VycmVuY3lfY29kZScsXHJcbiAgZGVzdGluYXRpb24gPSAnZGVzdGluYXRpb24nLFxyXG4gIHBheW1lbnRfYW1vdW50ID0gJ3BheW1lbnRfYW1vdW50J1xyXG59XHJcblxyXG5leHBvcnQgZW51bSBBbHBoYU51bWVyaWMge1xyXG4gIGFscGhhX251bWVyaWMgPSAnYWxwaGFfbnVtZXJpYycsXHJcbiAgbnVtZXJpYyA9ICdudW1lcmljJyxcclxuICBhbHBoYWJldGljID0gJ2FscGhhYmV0aWMnLFxyXG4gIGFtb3VudCA9ICdhbW91bnQnXHJcbn1cclxuIl19

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

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

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

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

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-invoices.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-invoices.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { LaravelModel } from './api.models'\r\nimport { Currency, IdentificationType } from './api-catalog.interfaces'\r\n\r\nexport interface Document extends LaravelModel {\r\n  document_type_range_id: number\r\n  document_number: number\r\n  document_prefix: string\r\n  document_suffix: string\r\n  document_number_original: number\r\n  document_prefix_original: string\r\n  document_suffix_original: string\r\n  customer_id: number\r\n  customer_company_name: string\r\n  customer_email: string\r\n  customer_address_line1: string\r\n  customer_identification_number: string\r\n  customer_identification_type_id: number\r\n  provider_name: string\r\n  provider_identification_number: number\r\n  document_authorization_number: string\r\n  provider_extra_fields: {\r\n    phone: string\r\n    fax: string\r\n  }\r\n  document_id: number\r\n  created_at: string\r\n  updated_at: string\r\n  transaction_id: string\r\n  extra_fields: {\r\n    observation: string\r\n    document_date: string\r\n  }\r\n  customer_address_line2: string\r\n  customer_address_line3: string\r\n  customer_postal_code: string\r\n  customer_state: string\r\n  customer_county_name: string\r\n  customer_city_name: string\r\n  customer_country_id: number\r\n  status: number\r\n  user_id: number\r\n  customer_full_name: string\r\n  customer_phone_code: string\r\n  customer_phone_number: string\r\n  gmt_offset: string\r\n  customer_type_id: number\r\n  customer_extra_fields: string\r\n  installation_id: number\r\n  exchange: number\r\n  authorization_numbers: string\r\n  extra_fields_json: string\r\n  provider_extra_fields_json: string\r\n  document_type_range: DocumentTypeRange\r\n  items: DocumentItem[]\r\n  document_payments: DocumentPayment[]\r\n  payments: Payment[]\r\n}\r\n\r\nexport interface DocumentTypeRange extends LaravelModel {\r\n  id: number\r\n  provider_id: number\r\n  model_type: string\r\n  model_id: number\r\n  init_number: number\r\n  final_number: number\r\n  current_number: number\r\n  used_numbers: number\r\n  min_until_mail: number\r\n  prefix: string\r\n  sap_prefix: string\r\n  suffix: string\r\n  sap_suffix: string\r\n  external_generated: boolean\r\n  authorization_number: string\r\n  environment: string\r\n  is_manual: boolean\r\n  auto_activation: boolean\r\n  activation_key: string\r\n  authorization_label: string\r\n  valid_since: string\r\n  valid_until: string\r\n  created_at: string\r\n  updated_at: string\r\n  is_active: boolean\r\n  country_document_type_id: number\r\n}\r\n\r\nexport interface DocumentItem extends LaravelModel {\r\n  id: number\r\n  document_id: number\r\n  details: {\r\n    account: number\r\n    country_reference_currency_id: number\r\n    customer_company_name: string\r\n  }\r\n  model_origin: string\r\n  model_type: string\r\n  model_id: number\r\n  quantity: number\r\n  unit_price: number\r\n  subtotal: number\r\n  tax_detail: {}\r\n  total: number\r\n  created_at: string\r\n  updated_at: string\r\n  discount: 0\r\n  details_json: string\r\n}\r\n\r\nexport interface DocumentPayment extends LaravelModel {\r\n  id: number\r\n  document_id: number\r\n  payment_id: number\r\n  amount: number\r\n  created_at: string\r\n  updated_at: string\r\n  payment: Payment\r\n}\r\n\r\nexport interface Payment extends LaravelModel {\r\n  id: number\r\n  amount: number\r\n  country_reference_currency_id: number\r\n  exchange: number\r\n  company_country_payment_type_id: number\r\n  due_date: string\r\n  received: number\r\n  status: number\r\n  details: {}\r\n  created_at: string\r\n  updated_at: string\r\n  transaction_id: string\r\n  gmt_offset: string\r\n  country_payment_type_id: number\r\n  opening_id: number\r\n  installation_id: number\r\n  details_json: {}\r\n  payment_adjustment: {}\r\n  pivot: {\r\n    document_id: number\r\n    payment_id: number\r\n    amount: number\r\n  }\r\n}\r\n\r\nexport interface Customer extends LaravelModel {\r\n  identification_number: number\r\n  company_name: string\r\n  full_name: string\r\n  email: string\r\n  phone_code: string\r\n  phone_number: number\r\n  birth_date: string\r\n  postal_code: number\r\n  state: string\r\n  county_name: string\r\n  city_name: string\r\n  address_line1: string\r\n  address_line2: string\r\n  address_line3: string\r\n  company_id: number\r\n  identification_type_id: number\r\n  extra_fields: {\r\n    [key: string]: string\r\n  }\r\n  country_id: number\r\n  customer_type_id: number\r\n}\r\n\r\nexport interface CustomerType extends LaravelModel {\r\n  country_id: number\r\n  identification_type_customer_types: IdentificationTypeCustomer[]\r\n  name: string\r\n}\r\n\r\nexport interface IdentificationTypeCustomer extends LaravelModel {\r\n  customer_type_id: number\r\n  identification_type_id: number\r\n  customer_id: number | null\r\n  identificationType: IdentificationType\r\n}\r\n\r\nexport interface CountryPaymentType extends LaravelModel {\r\n  payment_type_id: number\r\n  country_id: number\r\n  name: string\r\n  billing_payment_code: string\r\n  can_tolerance: boolean\r\n  code: string\r\n  country_payment_type_fields: CountryPaymentTypeField[]\r\n  payment_type: PaymentType\r\n}\r\n\r\nexport interface CountryPaymentTypeField extends LaravelModel {\r\n  country_payment_type_id: number\r\n  code: string\r\n  name: string\r\n  description: string\r\n  format: string\r\n  is_required: boolean\r\n  catalog: [] | null\r\n  regex: string | null\r\n  is_interface: boolean\r\n  value?: string\r\n  is_bank_reference: boolean\r\n}\r\n\r\nexport interface PaymentType extends LaravelModel {\r\n  code: string\r\n  fields: {\r\n    [key: string]: string\r\n  },\r\n  name: string\r\n}\r\n\r\nexport interface PaymentTypeFieldCardType extends LaravelModel {\r\n  country_payment_type_field_id: number\r\n  name: string\r\n  code: string\r\n  accountable_account: string\r\n  accountable_account_usd: string | null\r\n}\r\n\r\nexport interface PaymentTypeFieldAccount extends LaravelModel {\r\n  country_payment_type_field_id: number\r\n  name: string\r\n  account: string\r\n  accountable_account: string\r\n  currency_id: number\r\n  currency: Currency\r\n}\r\n"]}

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

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

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

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