@experteam-mx/ngx-services 20.0.1 → 20.0.3

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

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

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

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

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

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

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

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-reports.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-reports.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { OperationType } from './api-catalog.interfaces'\r\nimport { ActiveLessLaravelModel, ActiveLessSymfonyModel, ApiModel, LaravelModel, Translations } from './api.models'\r\n\r\nexport interface CollectionPayment extends LaravelModel {\r\n  _id: number,\r\n  country_code: string,\r\n  country_id: number,\r\n  country_name: string,\r\n  company_id: number,\r\n  company_name: string,\r\n  company_country_id: number,\r\n  installation_id: number,\r\n  installation_number: number,\r\n  location_facility_code: string,\r\n  location_id: number,\r\n  location_location_code: string,\r\n  location_name: string,\r\n  user_id: number,\r\n  user_username: string,\r\n  document_type_id: number,\r\n  document_type: DocumentTypeReports,\r\n  document_category_id: number,\r\n  document_category: DocumentCategoryReports,\r\n  receipt_number: string,\r\n  customer_name: string,\r\n  account: string,\r\n  amount: number,\r\n  currency_id: number,\r\n  currency_code: string\r\n  operation_type_id: number\r\n  operation_type: OperationType\r\n}\r\n\r\nexport interface DocumentTypeReports extends LaravelModel {\r\n  _id: number,\r\n  name: string,\r\n  code: string,\r\n  movement_type: number,\r\n  local_code: string,\r\n  translations: Translations\r\n}\r\n\r\nexport interface DocumentCategoryReports extends LaravelModel {\r\n  _id: number,\r\n  name: string,\r\n  is_electronic: true,\r\n  taxable: number,\r\n  created_at: string,\r\n  updated_at: string,\r\n  translations: Translations\r\n}\r\n\r\nexport interface ShipmentReports {\r\n  authorization_numbers: string[]\r\n  commercial_invoice: boolean\r\n  company_name: string\r\n  country_id: number\r\n  country_name: string\r\n  currency_code: string\r\n  customer_identification_number: string | null\r\n  customer_identification_type_id: number | null\r\n  document_id: number\r\n  id: number\r\n  installation_id: number\r\n  installation_number: number\r\n  invoice_document_id: number | null\r\n  is_document: boolean\r\n  is_manual: boolean\r\n  itn_number: string | null\r\n  location_id: number\r\n  location_name: string\r\n  price_override_approver_name: string | null\r\n  price_override_reason_name: string | null\r\n  product_subtotal: number\r\n  product_tax: number\r\n  question_description: string | null\r\n  receiver_company_name: string\r\n  receiver_full_name: string\r\n  send_to_api_inventories: boolean\r\n  shipment_id: number\r\n  shipment_pieces_tracking_numbers: string[]\r\n  shipment_status_code: string\r\n  shipment_status_description: string\r\n  shipment_status_id: number\r\n  shipment_status_translations: Translations\r\n  shipment_tags: ShipmentTag[]\r\n  shipment_tracking_number: string\r\n  shipment_type: string\r\n  shipment_value: string\r\n  shipper_account: string\r\n  shipper_address_line1: string\r\n  shipper_address_line2: string | null\r\n  shipper_address_line3: string | null\r\n  shipper_city_name: string\r\n  shipper_company_name: string\r\n  shipper_email: string\r\n  shipper_full_name: string\r\n  shipper_full_phone_number: string\r\n  shipper_identification_number: string | null\r\n  shipper_phone_number: string\r\n  shipper_postal_code: string\r\n  shipper_state_name: string | null\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  tracking: string | null\r\n  updated_at: string\r\n  user_id: number\r\n  user_username: string\r\n  additional_documents: {\r\n    country_id: number\r\n    include_indemnity_letter: boolean\r\n    shipment_content_type_id: number\r\n    shipment_scope_id: number\r\n  }\r\n  document_payments: {\r\n    payment: {\r\n      countryPaymentType: {\r\n        code: string\r\n      }\r\n    }\r\n  }[]\r\n}\r\n\r\nexport interface ShipmentLandingReport extends ActiveLessLaravelModel {\r\n  authorization_numbers: string[] | null\r\n  commercial_invoice: boolean | null\r\n  company_id: number\r\n  company_name: string\r\n  country_id: number\r\n  country_name: string\r\n  currency_code: string | null\r\n  document_id: number\r\n  hasCreditCardPayment: boolean\r\n  installation_id: number\r\n  installation_number: number\r\n  invoice_document_id: number | null\r\n  is_document: boolean\r\n  is_manual: boolean\r\n  itn_number: string | null\r\n  location_code: string\r\n  location_facility_code: string\r\n  location_id: number\r\n  location_name: string\r\n  price_override_approver_name: string | null\r\n  price_override_reason_name: string | null\r\n  product_global_name: string\r\n  product_local_name: string\r\n  question_description: string | null\r\n  receiver_address_line1: string\r\n  receiver_address_line2: string | null\r\n  receiver_address_line3: string | null\r\n  receiver_city_name: string\r\n  receiver_company_name: string\r\n  receiver_country_name: string\r\n  receiver_county_name: string | null\r\n  receiver_email: string | null\r\n  receiver_full_name: string\r\n  receiver_full_phone_number: string | null\r\n  receiver_identification_number: string | null\r\n  receiver_postal_code: string | null\r\n  receiver_state_name: string\r\n  send_to_api_inventories: boolean\r\n  shipment_description: string\r\n  shipment_group_id: number\r\n  shipment_group_name: string\r\n  shipment_pieces_tracking_numbers: string[]\r\n  shipment_status_code: string\r\n  shipment_status_id: number\r\n  shipment_status_name_EN: string\r\n  shipment_status_name_ES: string\r\n  shipment_status_name_FR: string\r\n  shipment_status_name_PT: string\r\n  shipment_tags: ShipmentTag[]\r\n  shipment_tracking_number: string\r\n  shipment_type: string\r\n  shipment_value: number\r\n  shipper_account: string\r\n  shipper_address_line1: string\r\n  shipper_address_line2: string | null\r\n  shipper_address_line3: string | null\r\n  shipper_city_name: string | null\r\n  shipper_company_name: string\r\n  shipper_country_name: string\r\n  shipper_county_name: string | null\r\n  shipper_email: string | null\r\n  shipper_full_name: string\r\n  shipper_full_phone_number: string\r\n  shipper_identification_number: string | null\r\n  shipper_phone_number: string | null\r\n  shipper_postal_code: string | null\r\n  shipper_state_name: string | null\r\n  tracking: string | null\r\n  user_id: number\r\n  user_username: string\r\n  additional_documents: {\r\n    country_id: number\r\n    include_indemnity_letter: boolean\r\n    shipment_content_type_id: number\r\n    shipment_scope_id: number\r\n  } | null\r\n}\r\n\r\nexport interface ShipmentTag extends ActiveLessSymfonyModel {\r\n  name: string\r\n  code: string\r\n  translations: Translations\r\n}\r\n\r\nexport interface ReportExternalShipment extends ActiveLessLaravelModel {\r\n  account_number: string\r\n  collection_date: string\r\n  document_id: number | null\r\n  document_number: string | null\r\n  external_shipment_addresses: ReportExternalShipmentAddress[]\r\n  external_shipment_file_id: number\r\n  external_shipment_status_id: number\r\n  external_shipment_status_name: string\r\n  external_shipment_status_translations: Translations\r\n  installation_id: number\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  tracking_number: string\r\n  user_id: number\r\n}\r\n\r\nexport interface ReportExternalShipmentAddress extends ApiModel {\r\n  address_line_1: string\r\n  address_line_2: string\r\n  city_name: string\r\n  company_name: string\r\n  country_id: number\r\n  email: string\r\n  full_name: string\r\n  identification_number: string | null\r\n  identification_type_id: number | null\r\n  phone_number: string\r\n  postal_code: string\r\n  role_type: string\r\n  service_area_code: string\r\n}\r\n\r\nexport interface PromotionCodeDiscount extends ApiModel {\r\n  country_id: number\r\n  company_country_id: number\r\n  location_id: number\r\n  installation_id: number\r\n  user_id: number\r\n  user_username: string\r\n  updated_at: Date | string\r\n  tracking_number: string\r\n  product_id: number\r\n  product_global_code: string\r\n  product_global_name: string\r\n  origin_facility_code: string\r\n  destination_facility_code: string\r\n  origin_company_name: string\r\n  origin_full_name: string\r\n  promotion_code: string\r\n  discount_percentage: number\r\n  product_subtotals: ProductSubtotal[]\r\n}\r\n\r\nexport interface ProductSubtotal {\r\n  country_reference_currency_id: number\r\n  currency_id: number\r\n  currency_code: string\r\n  value: number\r\n  shipment_total: number\r\n  discount_amount: number\r\n}\r\n\r\nexport interface WithdrawalAmount {\r\n  country_reference_currency_id: number\r\n  currency_id: number\r\n  currency_code: string\r\n  value: number | null\r\n}\r\n\r\nexport interface PartialWithdrawal extends ActiveLessLaravelModel {\r\n  country_id: number\r\n  company_country_id: number\r\n  location_id: number\r\n  installation_id: number\r\n  opening_user_id: number\r\n  opening_user_username: string\r\n  opening_user_name: string\r\n  opening_reference_user_id: number\r\n  opening_reference_user_username: string\r\n  opening_reference_user_name: string\r\n  receipt_number: string\r\n  amounts: WithdrawalAmount[]\r\n}\r\n\r\nexport interface Invoice extends ActiveLessLaravelModel {\r\n  complete_document_number: string\r\n  tracking_numbers: string[]\r\n  local_currency_total_amount: number\r\n  identification_type_name: string\r\n  identification_number: string\r\n  customer_full_name: string\r\n  customer_address: string\r\n  customer_email: string\r\n  customer_extra_fields: {\r\n    field: string\r\n    value: string\r\n  }[]\r\n  document_type_name: string\r\n  document_type_name_ES: string\r\n  document_type_name_EN: string\r\n  document_category_name: string\r\n  document_category_name_ES: string\r\n  document_category_name_EN: string\r\n  document_status_id: number\r\n  document_status_code: string\r\n  transaction_type: string\r\n  installation_id: number\r\n  location_id: number\r\n  company_country_id: number\r\n  country_id: number\r\n  customer_phone_code: string\r\n  customer_phone_number: string\r\n  customer_city_name: string\r\n  customer_county_name: string\r\n  shipment_id: number\r\n}\r\n\r\nexport interface Sales extends ActiveLessLaravelModel {\r\n  company_country_id: number\r\n  country_document_type_id: number\r\n  country_id: number\r\n  customer_address_line1: string\r\n  customer_email: string\r\n  customer_name: string\r\n  customer_phone: string\r\n  document_full_number: string\r\n  document_sap_full_number: string\r\n  document_status_name: string\r\n  document_status: number\r\n  document_type_name_EN: string\r\n  document_type_name_ES: string\r\n  document_type_name_FR: string\r\n  document_type_name_PT: string\r\n  document_type_name: string\r\n  exempt: number\r\n  identification_number: string\r\n  identification_type_id: number\r\n  identification_type_name: string\r\n  installation_id: number\r\n  location_id: number\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  user_id: number\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-reports.interfaces.js","sourceRoot":"","sources":["../../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/models/api-reports.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { OperationType } from './api-catalog.interfaces'\r\nimport { ActiveLessLaravelModel, ActiveLessSymfonyModel, ApiModel, LaravelModel, Translations } from './api.models'\r\n\r\nexport interface CollectionPayment extends LaravelModel {\r\n  _id: number,\r\n  country_code: string,\r\n  country_id: number,\r\n  country_name: string,\r\n  company_id: number,\r\n  company_name: string,\r\n  company_country_id: number,\r\n  installation_id: number,\r\n  installation_number: number,\r\n  location_facility_code: string,\r\n  location_id: number,\r\n  location_location_code: string,\r\n  location_name: string,\r\n  user_id: number,\r\n  user_username: string,\r\n  document_type_id: number,\r\n  document_type: DocumentTypeReports,\r\n  document_category_id: number,\r\n  document_category: DocumentCategoryReports,\r\n  receipt_number: string,\r\n  customer_name: string,\r\n  account: string,\r\n  amount: number,\r\n  currency_id: number,\r\n  currency_code: string\r\n  operation_type_id: number\r\n  operation_type: OperationType\r\n}\r\n\r\nexport interface DocumentTypeReports extends LaravelModel {\r\n  _id: number,\r\n  name: string,\r\n  code: string,\r\n  movement_type: number,\r\n  local_code: string,\r\n  translations: Translations\r\n}\r\n\r\nexport interface DocumentCategoryReports extends LaravelModel {\r\n  _id: number,\r\n  name: string,\r\n  is_electronic: true,\r\n  taxable: number,\r\n  created_at: string,\r\n  updated_at: string,\r\n  translations: Translations\r\n}\r\n\r\nexport interface ShipmentReports {\r\n  authorization_numbers: string[]\r\n  commercial_invoice: boolean\r\n  company_name: string\r\n  country_id: number\r\n  country_name: string\r\n  currency_code: string\r\n  customer_identification_number: string | null\r\n  customer_identification_type_id: number | null\r\n  document_id: number\r\n  id: number\r\n  installation_id: number\r\n  installation_number: number\r\n  invoice_document_id: number | null\r\n  is_document: boolean\r\n  is_manual: boolean\r\n  itn_number: string | null\r\n  location_id: number\r\n  location_name: string\r\n  price_override_approver_name: string | null\r\n  price_override_reason_name: string | null\r\n  product_subtotal: number\r\n  product_tax: number\r\n  question_description: string | null\r\n  receiver_company_name: string\r\n  receiver_full_name: string\r\n  send_to_api_inventories: boolean\r\n  shipment_id: number\r\n  shipment_pieces_tracking_numbers: string[]\r\n  shipment_status_code: string\r\n  shipment_status_description: string\r\n  shipment_status_id: number\r\n  shipment_status_translations: Translations\r\n  shipment_tags: ShipmentTag[]\r\n  shipment_tracking_number: string\r\n  shipment_type: string\r\n  shipment_value: string\r\n  shipper_account: string\r\n  shipper_address_line1: string\r\n  shipper_address_line2: string | null\r\n  shipper_address_line3: string | null\r\n  shipper_city_name: string\r\n  shipper_company_name: string\r\n  shipper_email: string\r\n  shipper_full_name: string\r\n  shipper_full_phone_number: string\r\n  shipper_identification_number: string | null\r\n  shipper_phone_number: string\r\n  shipper_postal_code: string\r\n  shipper_state_name: string | null\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  tracking: string | null\r\n  updated_at: string\r\n  user_id: number\r\n  user_username: string\r\n  additional_documents: {\r\n    country_id: number\r\n    include_indemnity_letter: boolean\r\n    shipment_content_type_id: number\r\n    shipment_scope_id: number\r\n  }\r\n  document_payments: {\r\n    payment: {\r\n      countryPaymentType: {\r\n        code: string\r\n      }\r\n    }\r\n  }[]\r\n}\r\n\r\nexport interface ShipmentLandingReport extends ActiveLessLaravelModel {\r\n  authorization_numbers: string[] | null\r\n  commercial_invoice: boolean | null\r\n  company_country_id: number\r\n  company_id: number\r\n  company_name: string\r\n  country_id: number\r\n  country_name: string\r\n  currency_code: string | null\r\n  document_id: number\r\n  hasCreditCardPayment: boolean\r\n  installation_id: number\r\n  installation_number: number\r\n  invoice_document_id: number | null\r\n  is_document: boolean\r\n  is_manual: boolean\r\n  itn_number: string | null\r\n  location_code: string\r\n  location_facility_code: string\r\n  location_id: number\r\n  location_name: string\r\n  price_override_approver_name: string | null\r\n  price_override_reason_name: string | null\r\n  product_global_name: string\r\n  product_local_name: string\r\n  question_description: string | null\r\n  receiver_address_line1: string\r\n  receiver_address_line2: string | null\r\n  receiver_address_line3: string | null\r\n  receiver_city_name: string\r\n  receiver_company_name: string\r\n  receiver_country_name: string\r\n  receiver_county_name: string | null\r\n  receiver_email: string | null\r\n  receiver_full_name: string\r\n  receiver_full_phone_number: string | null\r\n  receiver_identification_number: string | null\r\n  receiver_postal_code: string | null\r\n  receiver_state_name: string\r\n  send_to_api_inventories: boolean\r\n  shipment_description: string\r\n  shipment_group_id: number\r\n  shipment_group_name: string\r\n  shipment_pieces_tracking_numbers: string[]\r\n  shipment_status_code: string\r\n  shipment_status_id: number\r\n  shipment_status_name_EN: string\r\n  shipment_status_name_ES: string\r\n  shipment_status_name_FR: string\r\n  shipment_status_name_PT: string\r\n  shipment_tags: ShipmentTag[]\r\n  shipment_tracking_number: string\r\n  shipment_type: string\r\n  shipment_value: number\r\n  shipper_account: string\r\n  shipper_address_line1: string\r\n  shipper_address_line2: string | null\r\n  shipper_address_line3: string | null\r\n  shipper_city_name: string | null\r\n  shipper_company_name: string\r\n  shipper_country_name: string\r\n  shipper_county_name: string | null\r\n  shipper_email: string | null\r\n  shipper_full_name: string\r\n  shipper_full_phone_number: string\r\n  shipper_identification_number: string | null\r\n  shipper_phone_number: string | null\r\n  shipper_postal_code: string | null\r\n  shipper_state_name: string | null\r\n  tracking: string | null\r\n  user_id: number\r\n  user_username: string\r\n  additional_documents: {\r\n    country_id: number\r\n    include_indemnity_letter: boolean\r\n    shipment_content_type_id: number\r\n    shipment_scope_id: number\r\n  } | null\r\n}\r\n\r\nexport interface ShipmentTag extends ActiveLessSymfonyModel {\r\n  name: string\r\n  code: string\r\n  translations: Translations\r\n}\r\n\r\nexport interface ReportExternalShipment extends ActiveLessLaravelModel {\r\n  account_number: string\r\n  collection_date: string\r\n  document_id: number | null\r\n  document_number: string | null\r\n  external_shipment_addresses: ReportExternalShipmentAddress[]\r\n  external_shipment_file_id: number\r\n  external_shipment_status_id: number\r\n  external_shipment_status_name: string\r\n  external_shipment_status_translations: Translations\r\n  installation_id: number\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  tracking_number: string\r\n  user_id: number\r\n  customer_full_name: string\r\n  customer_email: string | null\r\n  customer_phone_code: string | null\r\n  customer_phone_number: string | null\r\n}\r\n\r\nexport interface ReportExternalShipmentAddress extends ApiModel {\r\n  address_line_1: string\r\n  address_line_2: string\r\n  city_name: string\r\n  company_name: string\r\n  country_id: number\r\n  email: string\r\n  full_name: string\r\n  identification_number: string | null\r\n  identification_type_id: number | null\r\n  phone_number: string\r\n  postal_code: string\r\n  role_type: string\r\n  service_area_code: string\r\n}\r\n\r\nexport interface PromotionCodeDiscount extends ApiModel {\r\n  country_id: number\r\n  company_country_id: number\r\n  location_id: number\r\n  installation_id: number\r\n  user_id: number\r\n  user_username: string\r\n  updated_at: Date | string\r\n  tracking_number: string\r\n  product_id: number\r\n  product_global_code: string\r\n  product_global_name: string\r\n  origin_facility_code: string\r\n  destination_facility_code: string\r\n  origin_company_name: string\r\n  origin_full_name: string\r\n  promotion_code: string\r\n  discount_percentage: number\r\n  product_subtotals: ProductSubtotal[]\r\n}\r\n\r\nexport interface ProductSubtotal {\r\n  country_reference_currency_id: number\r\n  currency_id: number\r\n  currency_code: string\r\n  value: number\r\n  shipment_total: number\r\n  discount_amount: number\r\n}\r\n\r\nexport interface WithdrawalAmount {\r\n  country_reference_currency_id: number\r\n  currency_id: number\r\n  currency_code: string\r\n  value: number | null\r\n}\r\n\r\nexport interface PartialWithdrawal extends ActiveLessLaravelModel {\r\n  country_id: number\r\n  company_country_id: number\r\n  location_id: number\r\n  installation_id: number\r\n  opening_user_id: number\r\n  opening_user_username: string\r\n  opening_user_name: string\r\n  opening_reference_user_id: number\r\n  opening_reference_user_username: string\r\n  opening_reference_user_name: string\r\n  receipt_number: string\r\n  amounts: WithdrawalAmount[]\r\n}\r\n\r\nexport interface Invoice extends ActiveLessLaravelModel {\r\n  complete_document_number: string\r\n  tracking_numbers: string[]\r\n  local_currency_total_amount: number\r\n  identification_type_name: string\r\n  identification_number: string\r\n  customer_full_name: string\r\n  customer_address: string\r\n  customer_email: string\r\n  customer_extra_fields: {\r\n    field: string\r\n    value: string\r\n  }[]\r\n  document_type_name: string\r\n  document_type_name_ES: string\r\n  document_type_name_EN: string\r\n  document_category_name: string\r\n  document_category_name_ES: string\r\n  document_category_name_EN: string\r\n  document_status_id: number\r\n  document_status_code: string\r\n  transaction_type: string\r\n  installation_id: number\r\n  location_id: number\r\n  company_country_id: number\r\n  country_id: number\r\n  customer_phone_code: string\r\n  customer_phone_number: string\r\n  customer_city_name: string\r\n  customer_county_name: string\r\n  shipment_id: number\r\n}\r\n\r\nexport interface Sales extends ActiveLessLaravelModel {\r\n  company_country_id: number\r\n  country_document_type_id: number\r\n  country_id: number\r\n  customer_address_line1: string\r\n  customer_email: string\r\n  customer_name: string\r\n  customer_phone: string\r\n  document_full_number: string\r\n  document_sap_full_number: string\r\n  document_status_name: string\r\n  document_status: number\r\n  document_type_name_EN: string\r\n  document_type_name_ES: string\r\n  document_type_name_FR: string\r\n  document_type_name_PT: string\r\n  document_type_name: string\r\n  exempt: number\r\n  identification_number: string\r\n  identification_type_id: number\r\n  identification_type_name: string\r\n  installation_id: number\r\n  location_id: number\r\n  subtotal: number\r\n  tax: number\r\n  total: number\r\n  user_id: number\r\n}\r\n"]}

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

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

package/esm2022/public-api.mjs

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

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

@@ -3509,6 +3509,89 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
 
+/**
+ * Service to manage quote-related events.
+ *
+ * This service provides methods to retrieve, create, and get event types
+ * related to quote processes.
+ */
+class ApiQuoteService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Base URL for the Quotes API.
+     */
+    get url() {
+        return this.environments.apiQuotesUrl ?? '';
+    }
+    /**
+     * Retrieves all registered events for a specific quote.
+     *
+     * @param id - Quote identifier.
+     * @param params - Optional query parameters such as pagination or filtering.
+     * @returns Observable containing the list of quote events.
+     *
+     * @example
+     * ```ts
+     * this.apiQuoteService.getQuoteEvents(10, { page: 1 })
+     *   .subscribe((events) => console.log(events))
+     * ```
+     */
+    getQuoteEvents(id, params) {
+        return this.http.get(`${this.url}/quotes/${id}/quote-events`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Registers a new event related to a specific quote.
+     *
+     * @param id - Quote identifier.
+     * @param body - Event payload to be created.
+     * @returns Observable containing the newly created event.
+     *
+     * @example
+     * ```ts
+     * const event: QuoteEventIn = { code: 'WON', note: 'Client approved' }
+     * this.apiQuoteService.postQuoteEvents(10, event)
+     *   .subscribe((response) => console.log(response))
+     * ```
+     */
+    postQuoteEvents(id, body) {
+        return this.http.post(`${this.url}/quotes/${id}/quote-events`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the available quote event types.
+     *
+     * @param params - Optional query parameters such as pagination or filtering.
+     * @returns Observable containing the list of event types.
+     *
+     * @example
+     * ```ts
+     * this.apiQuoteService.getQuoteEventTypes({ page: 1 })
+     *   .subscribe((types) => console.log(types))
+     * ```
+     */
+    getQuoteEventTypes(params) {
+        return this.http.get(`${this.url}/quote-event-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: ApiQuoteService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: ApiQuoteService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: ApiQuoteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+
 class ApiReportsService {
     environments;
     http;
@@ -4726,5 +4809,5 @@ const xmlHeaders = (format = 'object') => {
  * Generated bundle index. Do not edit.
  */
 
-export { AlphaNumeric, ApiBillingDOService, ApiBillingGtService, ApiBillingMxService, ApiBillingPaService, ApiBillingSvService, ApiCashOperationsService, ApiCatalogsService, ApiCompaniesService, ApiCompositionService, ApiCustomsService, ApiDiscountsService, ApiEToolsAutoBillingService, ApiEventsService, ApiExternalOperationsService, ApiInventoriesService, ApiInvoicesService, ApiNotificationsService, ApiOpenItemsService, ApiReportsService, ApiSecurityService, ApiServicesService, ApiShipmentsService, ApiSuppliesService, CryptoService, DefaultValueType, ENVIRONMENT_TOKEN, Event, NgxServicesModule, OperationModuleStatus, ViewSectionOption, WebSocketsService, apiHeadersInterceptor, apiKeyInterceptor, apiTokenInterceptor, base64PdfToUrl, downloadBase64Pdf, httpCachingInterceptor, httpParams, pdfHeaders, queryString, xmlHeaders };
+export { AlphaNumeric, ApiBillingDOService, ApiBillingGtService, ApiBillingMxService, ApiBillingPaService, ApiBillingSvService, ApiCashOperationsService, ApiCatalogsService, ApiCompaniesService, ApiCompositionService, ApiCustomsService, ApiDiscountsService, ApiEToolsAutoBillingService, ApiEventsService, ApiExternalOperationsService, ApiInventoriesService, ApiInvoicesService, ApiNotificationsService, ApiOpenItemsService, ApiQuoteService, ApiReportsService, ApiSecurityService, ApiServicesService, ApiShipmentsService, ApiSuppliesService, CryptoService, DefaultValueType, ENVIRONMENT_TOKEN, Event, NgxServicesModule, OperationModuleStatus, ViewSectionOption, WebSocketsService, apiHeadersInterceptor, apiKeyInterceptor, apiTokenInterceptor, base64PdfToUrl, downloadBase64Pdf, httpCachingInterceptor, httpParams, pdfHeaders, queryString, xmlHeaders };
 //# sourceMappingURL=experteam-mx-ngx-services.mjs.map