@acontplus/core 1.0.4 → 1.0.6

package/index.cjs.js

@@ -0,0 +1,742 @@
+'use strict';
+
+var utils = require('@acontplus/utils');
+var uuid = require('uuid');
+
+class AxiosAdapter {
+  constructor() {
+    //this.axios = axios.create({ baseURL: HttpClientFactory.getBaseURL() });
+  }
+  async get(url, options) {
+    // const res = await this.axios.get<T>(url, { headers: options?.headers, params: options?.params });
+    //   return res.data;
+    throw new Error('override');
+  }
+  delete(url, options) {
+    throw new Error('override');
+  }
+  post(url, body, options) {
+    throw new Error('override');
+  }
+  put(url, body, options) {
+    throw new Error('override');
+  }
+}
+
+/**
+ * Clase que actúa como fábrica y contenedor para un cliente HTTP configurable.
+ * Es agnóstica al framework, por lo que puede usarse en React, Vue, Angular, etc.
+ */
+class HttpClientFactory {
+  /**
+   * Configura el cliente HTTP y opcionalmente la URL base.
+   * Este método debe llamarse al iniciar la aplicación.
+   *
+   * @param client - Instancia que implementa HttpPort (por ejemplo, AxiosAdapter)
+   * @param baseURL - URL base para las peticiones (opcional)
+   */
+  static configure(client, baseURL) {
+    this.client = client;
+    if (baseURL) this.baseURL = baseURL;
+  }
+  /**
+   * Devuelve el cliente HTTP configurado.
+   * Si no se ha configurado explícitamente, se usa el cliente por defecto.
+   *
+   * @returns Instancia de HttpPort
+   */
+  static getClient() {
+    if (!this.client) {
+      throw new Error('HttpClientFactory: No se configuró ningún cliente HTTP');
+    }
+    return this.client;
+  }
+  /**
+   * Devuelve la URL base configurada.
+   * Si no se ha definido, retorna una cadena vacía.
+   *
+   * @returns string con la baseURL
+   */
+  static getBaseURL() {
+    return this.baseURL;
+  }
+}
+
+class FetchAdapter {
+  async get(url, options) {
+    return this.request('GET', url, undefined, options);
+  }
+  async post(url, body, options) {
+    return this.request('POST', url, body, options);
+  }
+  async put(url, body, options) {
+    return this.request('PUT', url, body, options);
+  }
+  async delete(url, options) {
+    return this.request('DELETE', url, undefined, options);
+  }
+  async request(method, url, body, options) {
+    const baseURL = HttpClientFactory.getBaseURL();
+    const response = await fetch(`${baseURL}${url}`, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(options?.headers || {})
+      },
+      body: body ? JSON.stringify(body) : undefined
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error ${response.status}`);
+    }
+    return response.json();
+  }
+}
+
+exports.SRI_DOCUMENT_TYPE = void 0;
+(function (SRI_DOCUMENT_TYPE) {
+  SRI_DOCUMENT_TYPE["RUC"] = "04";
+  SRI_DOCUMENT_TYPE["CEDULA"] = "05";
+  SRI_DOCUMENT_TYPE["PASSPORT"] = "06";
+  SRI_DOCUMENT_TYPE["CONSUMIDOR_FINAL"] = "07";
+  SRI_DOCUMENT_TYPE["IDENTIFICACION_EXTERIOR"] = "08";
+})(exports.SRI_DOCUMENT_TYPE || (exports.SRI_DOCUMENT_TYPE = {}));
+exports.SRI_DOCUMENT_TYPE_CUSTOM = void 0;
+(function (SRI_DOCUMENT_TYPE_CUSTOM) {
+  SRI_DOCUMENT_TYPE_CUSTOM["RUC"] = "R";
+  SRI_DOCUMENT_TYPE_CUSTOM["CEDULA"] = "C";
+  SRI_DOCUMENT_TYPE_CUSTOM["PASSPORT"] = "P";
+  SRI_DOCUMENT_TYPE_CUSTOM["CONSUMIDOR_FINAL"] = "CF";
+  SRI_DOCUMENT_TYPE_CUSTOM["IDENTIFICACION_EXTERIOR"] = "IE";
+})(exports.SRI_DOCUMENT_TYPE_CUSTOM || (exports.SRI_DOCUMENT_TYPE_CUSTOM = {}));
+exports.SEPARATOR_KEY_CODE = void 0;
+(function (SEPARATOR_KEY_CODE) {
+  SEPARATOR_KEY_CODE["SLASH"] = "|";
+  SEPARATOR_KEY_CODE["PUNTO_COMA"] = ";";
+  SEPARATOR_KEY_CODE["DOS_PUNTOS"] = ":";
+})(exports.SEPARATOR_KEY_CODE || (exports.SEPARATOR_KEY_CODE = {}));
+const SEPARADORES_REGEX = new RegExp(`[${Object.values(exports.SEPARATOR_KEY_CODE).join('')}]`);
+
+const isSuccessResponse = response => response?.status === 'success';
+const isErrorResponse = response => response?.status === 'error';
+
+class LegacyApiResponse {
+  constructor(code = '0', message = '', payload = null) {
+    this.code = code;
+    this.message = message;
+    this.payload = payload;
+  }
+}
+
+class PaginationParams {
+  constructor(params) {
+    this._pageIndex = 1;
+    this._pageSize = 10;
+    this.sortDirection = 'asc';
+    if (params) {
+      this.pageIndex = params.pageIndex ?? 1;
+      this.pageSize = params.pageSize ?? 10;
+      this.sortBy = params.sortBy;
+      this.sortDirection = params.sortDirection ?? 'asc';
+      this.searchTerm = params.searchTerm;
+      this.filters = params.filters;
+    }
+  }
+  get pageIndex() {
+    return this._pageIndex;
+  }
+  set pageIndex(value) {
+    this._pageIndex = value < 1 ? 1 : value;
+  }
+  get pageSize() {
+    return this._pageSize;
+  }
+  set pageSize(value) {
+    this._pageSize = value < 1 ? 10 : value > 1000 ? 1000 : value;
+  }
+  get skip() {
+    return (this.pageIndex - 1) * this.pageSize;
+  }
+  get take() {
+    return this.pageSize;
+  }
+  get isEmpty() {
+    return (!this.searchTerm || this.searchTerm.trim() === '') && (!this.filters || Object.keys(this.filters).length === 0);
+  }
+  buildFilters() {
+    if (!this.filters || Object.keys(this.filters).length === 0) return null;
+    return {
+      ...this.filters
+    };
+  }
+  buildFiltersWithPrefix(prefix) {
+    if (!this.filters || Object.keys(this.filters).length === 0) return null;
+    const result = {};
+    for (const key in this.filters) {
+      result[prefix + key] = this.filters[key];
+    }
+    return result;
+  }
+  buildSqlParameters() {
+    return this.buildFiltersWithPrefix('@');
+  }
+}
+
+class PricingCalculationError extends Error {
+  constructor(operation, originalError) {
+    super(`Pricing calculation failed for operation: ${operation}. ${originalError?.message || ''}`);
+    this.name = 'PricingCalculationError';
+  }
+}
+
+/**
+ * Calculadora especializada para descuentos
+ */
+class DiscountCalculator {
+  constructor(decimales = 4) {
+    this.decimales = decimales;
+  }
+  /**
+   * Calcula el valor del descuento a partir del porcentaje
+   * @param originalPrice - Precio antes del descuento
+   * @param discountPercentage - Porcentaje de descuento a aplicar (0-100)
+   * @returns Valor del descuento en moneda
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const valorDescuento = calculadora.calculateDiscountAmount(100, 10); // 10
+   * ```
+   */
+  calculateDiscountAmount(originalPrice, discountPercentage) {
+    try {
+      utils.ParameterValidator.validatePositiveNumber(originalPrice, 'originalPrice');
+      utils.ParameterValidator.validatePercentage(discountPercentage, 'discountPercentage');
+      const percentage = utils.DecimalConverter.divideAsNumber(discountPercentage, 100);
+      return utils.DecimalConverter.multiplyAsNumber(originalPrice, percentage);
+    } catch (error) {
+      throw new PricingCalculationError('calculateDiscountAmount', error);
+    }
+  }
+  /**
+   * Aplica un descuento al precio original
+   * @param originalPrice - Precio antes del descuento
+   * @param discountPercentage - Porcentaje de descuento a aplicar
+   * @returns Precio final después del descuento
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const precioConDescuento = calculadora.applyDiscount(100, 10); // 90
+   * ```
+   */
+  applyDiscount(originalPrice, discountPercentage) {
+    try {
+      const discountAmount = this.calculateDiscountAmount(originalPrice, discountPercentage);
+      return utils.DecimalConverter.subtractAsNumber(originalPrice, discountAmount);
+    } catch (error) {
+      throw new PricingCalculationError('applyDiscount', error);
+    }
+  }
+  /**
+   * Calcula el porcentaje de descuento a partir de los valores
+   * @param originalPrice - Precio antes del descuento
+   * @param discountAmount - Valor del descuento aplicado
+   * @returns Porcentaje de descuento
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const porcentaje = calculadora.calculateDiscountPercentage(100, 10); // 10
+   * ```
+   */
+  calculateDiscountPercentage(originalPrice, discountAmount) {
+    try {
+      utils.ParameterValidator.validatePositiveNumber(originalPrice, 'originalPrice');
+      utils.ParameterValidator.validatePositiveNumber(discountAmount, 'discountAmount');
+      if (discountAmount > originalPrice) {
+        throw new utils.InvalidParameterError('discountAmount', 'No puede ser mayor que el precio original');
+      }
+      const percentage = utils.DecimalConverter.divideAsNumber(discountAmount, originalPrice);
+      return utils.DecimalConverter.multiplyAsNumber(percentage, 100);
+    } catch (error) {
+      throw new PricingCalculationError('calculateDiscountPercentage', error);
+    }
+  }
+  /**
+   * Obtiene los detalles completos del cálculo de descuento
+   * @param originalPrice - Precio antes del descuento
+   * @param discountPercentage - Porcentaje de descuento a aplicar
+   * @returns Objeto con todos los detalles del cálculo
+   * @example
+   * ```typescript
+   * const detalles = calculadora.getDiscountCalculationDetails(100, 10);
+   * // { originalPrice: 100, discountRate: 10, discountAmount: 10, finalPrice: 90 }
+   * ```
+   */
+  getDiscountCalculationDetails(originalPrice, discountPercentage) {
+    const discountAmount = this.calculateDiscountAmount(originalPrice, discountPercentage);
+    const finalPrice = this.applyDiscount(originalPrice, discountPercentage);
+    return {
+      originalPrice,
+      discountRate: discountPercentage,
+      discountAmount,
+      finalPrice
+    };
+  }
+}
+
+/**
+ * Calculadora especializada para líneas de productos/servicios en facturas
+ */
+class LineItemCalculator {
+  constructor(decimales = 4) {
+    this.decimales = decimales;
+  }
+  /**
+   * Calcula el total de una línea de producto incluyendo descuentos e impuestos
+   * @param unitPrice - Precio por unidad del producto
+   * @param quantity - Cantidad de productos
+   * @param discountAmount - Valor del descuento a aplicar (por defecto 0)
+   * @param taxAmount - Valor del impuesto a aplicar (por defecto 0)
+   * @returns Objeto con todos los cálculos de la línea
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const linea = calculadora.calcularTotalLinea(50, 2, 10, 8.4);
+   * // Resultado: subtotal: 100, con descuento: 90, total con impuesto: 98.4
+   * ```
+   */
+  calculateLineItemTotal(unitPrice, quantity, discountAmount = 0, taxAmount = 0) {
+    try {
+      utils.ParameterValidator.validatePositiveNumber(unitPrice, 'unitPrice');
+      utils.ParameterValidator.validatePositiveNumber(quantity, 'quantity');
+      utils.ParameterValidator.validatePositiveNumber(discountAmount, 'discountAmount');
+      utils.ParameterValidator.validatePositiveNumber(taxAmount, 'taxAmount');
+      const subtotal = utils.DecimalConverter.multiplyAsNumber(unitPrice, quantity);
+      const subtotalAfterDiscount = utils.DecimalConverter.subtractAsNumber(subtotal, discountAmount);
+      const total = utils.DecimalConverter.addAsNumber(subtotalAfterDiscount, taxAmount);
+      return {
+        unitPrice,
+        quantity,
+        subtotal,
+        discountAmount,
+        subtotalAfterDiscount,
+        taxAmount,
+        total
+      };
+    } catch (error) {
+      throw new PricingCalculationError('calcularTotalLinea', error);
+    }
+  }
+  /**
+   * Calcula el subtotal antes de aplicar descuentos
+   * @param unitPrice - Precio por unidad
+   * @param quantity - Cantidad de productos
+   * @returns Subtotal calculado
+   * @example
+   * ```typescript
+   * const subtotal = calculadora.calculateSubtotal(25, 4); // 100
+   * ```
+   */
+  calculateSubtotal(unitPrice, quantity) {
+    return utils.DecimalConverter.multiplyAsNumber(unitPrice, quantity);
+  }
+}
+
+/**
+ * Calculadora especializada para márgenes de ganancia y utilidades
+ */
+class ProfitCalculator {
+  constructor(decimals = 4) {
+    this.decimals = decimals;
+  }
+  /**
+   * Calcula el precio de venta a partir del costo y el margen de ganancia
+   * @param cost - Costo del producto o servicio
+   * @param profitMarginPercentage - Porcentaje de margen de ganancia deseado
+   * @returns Precio de venta calculado
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const precioVenta = calculadora.calculateSalePriceFromMargin(80, 25); // 100
+   * ```
+   */
+  calculateSalePriceFromMargin(cost, profitMarginPercentage) {
+    try {
+      utils.ParameterValidator.validatePositiveNumber(cost, 'cost');
+      utils.ParameterValidator.validatePositiveNumber(profitMarginPercentage, 'profitMarginPercentage');
+      const marginMultiplier = utils.DecimalConverter.divideAsNumber(profitMarginPercentage, 100);
+      const profitAmount = utils.DecimalConverter.multiplyAsNumber(cost, marginMultiplier);
+      return utils.DecimalConverter.addAsNumber(cost, profitAmount);
+    } catch (error) {
+      throw new PricingCalculationError('calculateSalePriceFromMargin', error);
+    }
+  }
+  /**
+   * Calcula el porcentaje de margen de ganancia a partir del precio de venta y costo
+   * @param salePrice - Precio de venta del producto
+   * @param cost - Costo del producto
+   * @returns Porcentaje de margen de ganancia
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const margen = calculadora.calculateProfitMarginPercentage(100, 80); // 25
+   * ```
+   */
+  calculateProfitMarginPercentage(salePrice, cost) {
+    try {
+      utils.ParameterValidator.validatePositiveNumber(salePrice, 'salePrice');
+      utils.ParameterValidator.validatePositiveNumber(cost, 'cost');
+      if (salePrice < cost) {
+        throw new utils.InvalidParameterError('salePrice', 'El precio de venta no puede ser menor que el costo');
+      }
+      const profitAmount = utils.DecimalConverter.subtractAsNumber(salePrice, cost);
+      const profitRatio = utils.DecimalConverter.divideAsNumber(profitAmount, cost);
+      return utils.DecimalConverter.multiplyAsNumber(profitRatio, 100);
+    } catch (error) {
+      throw new PricingCalculationError('calculateProfitMarginPercentage', error);
+    }
+  }
+  /**
+   * Calcula el valor de la ganancia
+   * @param salePrice - Precio de venta
+   * @param cost - Costo del producto
+   * @returns Valor de la ganancia obtenida
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const ganancia = calculadora.calculateProfitAmount(100, 80); // 20
+   * ```
+   */
+  calculateProfitAmount(salePrice, cost) {
+    try {
+      utils.ParameterValidator.validatePositiveNumber(salePrice, 'salePrice');
+      utils.ParameterValidator.validatePositiveNumber(cost, 'cost');
+      return utils.DecimalConverter.subtractAsNumber(salePrice, cost);
+    } catch (error) {
+      throw new PricingCalculationError('calculateProfitAmount', error);
+    }
+  }
+  /**
+   * Obtiene los detalles completos del cálculo de ganancia
+   * @param salePrice - Precio de venta
+   * @param cost - Costo del producto
+   * @returns Objeto con todos los detalles del cálculo
+   * @example
+   * ```typescript
+   * const detalles = calculadora.obtenerDetallesCalculoGanancia(100, 80);
+   * // { salePrice: 100, cost: 80, profitAmount: 20, profitMargin: 25 }
+   * ```
+   */
+  getProfitCalculationDetails(salePrice, cost) {
+    const profitAmount = this.calculateProfitAmount(salePrice, cost);
+    const profitMargin = this.calculateProfitMarginPercentage(salePrice, cost);
+    return {
+      salePrice,
+      cost,
+      profitAmount,
+      profitMargin
+    };
+  }
+}
+
+/**
+ * Calculadora especializada para impuestos (IVA, IGV, etc.)
+ */
+class TaxCalculator {
+  constructor(decimales = 4) {
+    this.decimales = decimales;
+  }
+  /**
+   * Calcula el valor del impuesto basado en el precio base y la tasa
+   * @param basePrice - Precio sin impuestos
+   * @param taxRate - Porcentaje del impuesto (ej: 21 para 21%)
+   * @returns Valor del impuesto calculado
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const calculadora = new TaxCalculator();
+   * const valorIva = calculadora.calculateTaxAmount(100, 21); // 21
+   * ```
+   */
+  calculateTaxAmount(basePrice, taxRate) {
+    try {
+      utils.ParameterValidator.validatePositiveNumber(basePrice, 'basePrice');
+      utils.ParameterValidator.validatePositiveNumber(taxRate, 'taxRate');
+      const multiplicador = utils.DecimalConverter.multiplyAsNumber(basePrice, taxRate);
+      return utils.DecimalConverter.divideAsNumber(multiplicador, 100);
+    } catch (error) {
+      throw new PricingCalculationError('calculateTaxAmount', error);
+    }
+  }
+  /**
+   * Calcula el precio incluyendo impuestos
+   * @param basePrice - Precio sin impuestos
+   * @param taxRate - Porcentaje del impuesto
+   * @returns Precio total con impuestos incluidos
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const precioConIva = calculadora.calculatePriceWithTax(100, 21); // 121
+   * ```
+   */
+  calculatePriceWithTax(basePrice, taxRate) {
+    try {
+      const taxAmount = this.calculateTaxAmount(basePrice, taxRate);
+      return utils.DecimalConverter.addAsNumber(basePrice, taxAmount);
+    } catch (error) {
+      throw new PricingCalculationError('calculatePriceWithTax', error);
+    }
+  }
+  /**
+   * Calcula el precio base a partir de un precio que ya incluye impuestos
+   * @param priceWithTax - Precio que incluye impuestos
+   * @param taxRate - Porcentaje del impuesto aplicado
+   * @returns Precio base sin impuestos
+   * @throws {PricingCalculationError} Si ocurre un error en el cálculo
+   * @example
+   * ```typescript
+   * const precioBase = calculadora.calculateBasePriceFromTaxIncluded(121, 21); // 100
+   * ```
+   */
+  calculateBasePriceFromTaxIncluded(priceWithTax, taxRate) {
+    try {
+      utils.ParameterValidator.validatePositiveNumber(priceWithTax, 'priceWithTax');
+      utils.ParameterValidator.validatePositiveNumber(taxRate, 'taxRate');
+      const taxMultiplier = utils.DecimalConverter.divideAsNumber(taxRate, 100);
+      const divisor = utils.DecimalConverter.addAsNumber(1, taxMultiplier);
+      return utils.DecimalConverter.divideAsNumber(priceWithTax, divisor);
+    } catch (error) {
+      throw new PricingCalculationError('calculateBasePriceFromTaxIncluded', error);
+    }
+  }
+  /**
+   * Obtiene los detalles completos del cálculo de impuestos
+   * @param basePrice - Precio sin impuestos
+   * @param taxRate - Porcentaje del impuesto
+   * @returns Objeto con todos los detalles del cálculo
+   * @example
+   * ```typescript
+   * const detalles = calculadora.getTaxCalculationDetails(100, 21);
+   * // { montoBase: 100, taxRate: 21, valorImpuesto: 21, montoTotal: 121 }
+   * ```
+   */
+  getTaxCalculationDetails(basePrice, taxRate) {
+    const taxAmount = this.calculateTaxAmount(basePrice, taxRate);
+    const totalAmount = this.calculatePriceWithTax(basePrice, taxRate);
+    return {
+      baseAmount: basePrice,
+      taxRate,
+      taxAmount,
+      totalAmount
+    };
+  }
+}
+
+class PricingCalculator {
+  constructor(config = {}) {
+    this.config = {
+      defaultDecimals: config.defaultDecimals ?? 4,
+      roundingMode: config.roundingMode ?? 'round',
+      errorHandling: config.errorHandling ?? 'throw'
+    };
+    this.tax = new TaxCalculator(this.config.defaultDecimals);
+    this.discount = new DiscountCalculator(this.config.defaultDecimals);
+    this.profit = new ProfitCalculator(this.config.defaultDecimals);
+    this.lineItem = new LineItemCalculator(this.config.defaultDecimals);
+  }
+  updateConfig(newConfig) {
+    this.config = {
+      ...this.config,
+      ...newConfig
+    };
+  }
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+}
+
+// src/domain/value-objects/base.vo.ts
+class BaseVo {
+  constructor(value) {
+    this.value = value;
+    this.validate(value);
+  }
+  getValue() {
+    return this.value;
+  }
+  equals(other) {
+    return JSON.stringify(this.value) === JSON.stringify(other.value);
+  }
+}
+
+class EntityIdVo extends BaseVo {
+  constructor(value) {
+    super(value);
+  }
+  static generate() {
+    return new EntityIdVo(uuid.v4());
+  }
+  validate(value) {
+    if (!value || value.trim().length === 0) {
+      throw new Error('EntityIdVo cannot be empty');
+    }
+  }
+}
+
+// src/domain/value-objects/money.vo.ts
+class MoneyVo extends BaseVo {
+  constructor(amount, currency = 'USD') {
+    super({
+      amount,
+      currency
+    });
+  }
+  validate(value) {
+    if (value.amount < 0) throw new Error('Amount cannot be negative');
+    if (!value.currency || value.currency.length !== 3) {
+      throw new Error('Invalid currency code');
+    }
+  }
+  add(other) {
+    if (this.value.currency !== other.value.currency) {
+      throw new Error('Cannot add different currencies');
+    }
+    return new MoneyVo(this.value.amount + other.value.amount, this.value.currency);
+  }
+}
+
+class IdentificationNumberVo extends BaseVo {
+  constructor(id) {
+    super(id);
+    this.id = id?.trim() || '';
+    this.type = this.determineType();
+    if (!this.validate()) {
+      throw new Error(`Número de identificación inválido: ${this.id}`);
+    }
+  }
+  determineType() {
+    if (this.id.length === 10) return exports.SRI_DOCUMENT_TYPE.CEDULA;
+    if (this.id.length === 13) return exports.SRI_DOCUMENT_TYPE.RUC;
+    throw new Error('Número de identificación debe tener 10 o 13 dígitos');
+  }
+  validate() {
+    if (this.type === exports.SRI_DOCUMENT_TYPE.CEDULA) {
+      return this.isValidCedulaAlgorithm();
+    }
+    if (this.type === exports.SRI_DOCUMENT_TYPE.RUC) {
+      return this.isValidRucAlgorithm();
+    }
+    return false;
+  }
+  // Validación completa de cédula ecuatoriana con algoritmo
+  isValidCedulaAlgorithm() {
+    if (!/^\d{10}$/.test(this.id)) return false;
+    // Verificar que los primeros 2 dígitos sean una provincia válida (01-24)
+    const provincia = parseInt(this.id.substring(0, 2));
+    if (provincia < 1 || provincia > 24) return false;
+    // Algoritmo de validación del dígito verificador
+    const coeficientes = [2, 1, 2, 1, 2, 1, 2, 1, 2];
+    let suma = 0;
+    for (let i = 0; i < 9; i++) {
+      const valor = parseInt(this.id.charAt(i)) * coeficientes[i];
+      suma += valor > 9 ? valor - 9 : valor;
+    }
+    const digitoVerificador = suma % 10 === 0 ? 0 : 10 - suma % 10;
+    return digitoVerificador === parseInt(this.id.charAt(9));
+  }
+  // Validación de RUC más flexible
+  isValidRucAlgorithm() {
+    if (!/^\d{13}$/.test(this.id)) return false;
+    // Los primeros 10 dígitos deben ser una cédula válida para personas naturales
+    // o seguir reglas específicas para sociedades
+    const tercerDigito = parseInt(this.id.charAt(2));
+    // RUC de persona natural (tercer dígito < 6)
+    if (tercerDigito < 6) {
+      const cedula = this.id.substring(0, 10);
+      const tempCedula = IdentificationNumberVo.validateCedula(cedula);
+      return tempCedula && this.id.endsWith('001');
+    }
+    // RUC de sociedad privada (tercer dígito = 9)
+    if (tercerDigito === 9) {
+      return this.isValidSociedadRuc();
+    }
+    // RUC de entidad pública (tercer dígito = 6)
+    if (tercerDigito === 6) {
+      return this.id.endsWith('0001');
+    }
+    return false;
+  }
+  isValidSociedadRuc() {
+    const coeficientes = [4, 3, 2, 7, 6, 5, 4, 3, 2];
+    let suma = 0;
+    for (let i = 0; i < 9; i++) {
+      suma += parseInt(this.id.charAt(i)) * coeficientes[i];
+    }
+    const residuo = suma % 11;
+    const digitoVerificador = residuo === 0 ? 0 : 11 - residuo;
+    return digitoVerificador === parseInt(this.id.charAt(9)) && this.id.endsWith('001');
+  }
+  // Método auxiliar estático para validar cédula sin crear instancia
+  static validateCedula(cedula) {
+    if (!/^\d{10}$/.test(cedula)) return false;
+    const provincia = parseInt(cedula.substring(0, 2));
+    if (provincia < 1 || provincia > 24) return false;
+    const coeficientes = [2, 1, 2, 1, 2, 1, 2, 1, 2];
+    let suma = 0;
+    for (let i = 0; i < 9; i++) {
+      const valor = parseInt(cedula.charAt(i)) * coeficientes[i];
+      suma += valor > 9 ? valor - 9 : valor;
+    }
+    const digitoVerificador = suma % 10 === 0 ? 0 : 10 - suma % 10;
+    return digitoVerificador === parseInt(cedula.charAt(9));
+  }
+  // Métodos públicos mejorados
+  isValidCedula() {
+    return this.type === exports.SRI_DOCUMENT_TYPE.CEDULA && this.isValidCedulaAlgorithm();
+  }
+  isValidRuc() {
+    return this.type === exports.SRI_DOCUMENT_TYPE.RUC && this.isValidRucAlgorithm();
+  }
+  getId() {
+    return this.id;
+  }
+  getType() {
+    return this.type;
+  }
+  // Método estático mejorado
+  static tryCreate(id) {
+    try {
+      new IdentificationNumberVo(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // Método adicional para obtener información del tipo de RUC
+  getRucType() {
+    if (this.type !== exports.SRI_DOCUMENT_TYPE.RUC) return null;
+    const tercerDigito = parseInt(this.id.charAt(2));
+    if (tercerDigito < 6) return 'Persona Natural';
+    if (tercerDigito === 6) return 'Entidad Pública';
+    if (tercerDigito === 9) return 'Sociedad Privada';
+    return 'Desconocido';
+  }
+}
+
+exports.AxiosAdapter = AxiosAdapter;
+exports.BaseVo = BaseVo;
+exports.DiscountCalculator = DiscountCalculator;
+exports.EntityIdVo = EntityIdVo;
+exports.FetchAdapter = FetchAdapter;
+exports.HttpClientFactory = HttpClientFactory;
+exports.IdentificationNumberVo = IdentificationNumberVo;
+exports.LegacyApiResponse = LegacyApiResponse;
+exports.LineItemCalculator = LineItemCalculator;
+exports.MoneyVo = MoneyVo;
+exports.PaginationParams = PaginationParams;
+exports.PricingCalculator = PricingCalculator;
+exports.ProfitCalculator = ProfitCalculator;
+exports.SEPARADORES_REGEX = SEPARADORES_REGEX;
+exports.TaxCalculator = TaxCalculator;
+exports.isErrorResponse = isErrorResponse;
+exports.isSuccessResponse = isSuccessResponse;