arcli 2.0.0 → 2.2.0

package/dist/modules/export/export.mappers.js

@@ -0,0 +1,293 @@
+import { formatArcaDateAsArgentineDate, formatDateAsArcaDate, parseArgentineDateInputAsArcaDate, } from '../../lib/dates/arca-date.js';
+import { AppError, InputValidationError } from '../../lib/errors/app-error.js';
+import { resolveBillingCurrencyCode } from '../billing/billing.mappers.js';
+import { DEFAULT_EXPORT_CURRENCY_CODE, DEFAULT_EXPORT_LANGUAGE, DEFAULT_EXPORT_TYPE, EXPORT_TYPE_VALUES, EXPORT_TYPES, EXPORT_TYPES_WITHOUT_PERMITS, EXPORT_VOUCHER_KIND, MAX_EXPORT_VOUCHER_NUMBER, } from './export.types.js';
+/** Codigo de pais de Argentina en la tabla DST_pais: no es un destino de exportacion. */
+export const ARGENTINA_COUNTRY_CODE = 200;
+/** Forma de pago por defecto: WSFEX la exige y casi todas las exportaciones se cobran por transferencia internacional. */
+export const DEFAULT_EXPORT_PAYMENT_TERMS = 'Transferencia Internacional';
+/** ARCA no acepta cotizaciones en pesos distintas de 1. */
+const LOCAL_EXCHANGE_RATE = 1;
+function requireText(value, description, flag) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        throw new InputValidationError(`Falta ${description}. Usá ${flag}.`);
+    }
+    return trimmed;
+}
+function roundAmount(value) {
+    return Math.round(value * 100) / 100;
+}
+/** La fecha del comprobante, en formato ARCA: por defecto hoy en Argentina. */
+export function resolveExportVoucherDate(value, now = new Date()) {
+    return value?.trim() ? parseArgentineDateInputAsArcaDate(value) : formatDateAsArcaDate(now);
+}
+/**
+ * Acepta `ARS`, `USD` o los codigos de ARCA (`PES`, `DOL`). Sin `--moneda` la exportacion va en dolares; la moneda
+ * de la config es la de los comprobantes locales. Sin `--cotizacion-moneda` se usa la de aduana que publica ARCA
+ * (WSFEX no acepta `Moneda_ctz` en 0): la clave `cotizacion` de la config no aplica, porque una cotizacion guardada
+ * queda vieja en dias (REV-35).
+ */
+export function resolveExportCurrency(input) {
+    const requested = input.currencyCode?.trim() || DEFAULT_EXPORT_CURRENCY_CODE;
+    const currencyCode = resolveBillingCurrencyCode(requested);
+    const displayCode = requested.toUpperCase();
+    if (currencyCode === 'PES') {
+        if (input.sameCurrency) {
+            throw new InputValidationError('--misma-moneda solo aplica a comprobantes en moneda extranjera.');
+        }
+        if (typeof input.exchangeRate === 'number' && input.exchangeRate !== LOCAL_EXCHANGE_RATE) {
+            throw new InputValidationError('En pesos la cotización tiene que ser 1. Quitá --cotizacion-moneda o usá --cm 1.');
+        }
+        return {
+            fields: { CanMisMonExt: 'N', Moneda_ctz: LOCAL_EXCHANGE_RATE, Moneda_Id: currencyCode },
+            needsQuotation: false,
+        };
+    }
+    const rate = input.exchangeRate;
+    if (rate !== undefined && rate <= LOCAL_EXCHANGE_RATE) {
+        throw new InputValidationError(`La cotización de ${displayCode} tiene que ser mayor a 1.`);
+    }
+    return {
+        fields: {
+            CanMisMonExt: input.sameCurrency ? 'S' : 'N',
+            Moneda_ctz: rate ?? 0,
+            Moneda_Id: currencyCode,
+        },
+        needsQuotation: rate === undefined,
+    };
+}
+/**
+ * La cotizacion de aduana de la fecha del comprobante. WSFEX devuelve por moneda la ultima publicada, asi que el
+ * dia en curso —que todavia no tiene— o un fin de semana traen la anterior. Sin fila para la moneda no hay
+ * cotizacion que usar: es error, salvo que el usuario la informe con `--cotizacion-moneda`.
+ */
+export function resolveExportQuotation(currencyCode, quotations, voucherDate) {
+    const code = currencyCode.trim().toUpperCase();
+    const quotation = quotations.find((entry) => entry.code.trim().toUpperCase() === code);
+    if (quotation) {
+        return quotation;
+    }
+    const available = quotations.map((entry) => entry.code).join(', ');
+    throw new AppError(`ARCA no informó la cotización de ${code} para el ${formatArcaDateAsArgentineDate(voucherDate)}.${available ? ` Las monedas con cotización son ${available}.` : ''} Informá la cotización con --cotizacion-moneda.`, { code: 'ARCA_QUOTATION_ERROR' });
+}
+/**
+ * WSFEX exige una `Actividad` (error 2100) y solo acepta los codigos de su propia tabla, que no es la del padron y
+ * es mas chica (error 2105 al emitir). Cada emisor tiene la suya, asi que no hay default: sale de `--actividad` o de
+ * `exportacion.actividad`. Los nombres de la tabla llegan con la codificacion rota, por eso los mensajes solo dan codigos.
+ */
+export function resolveExportActivity(value, activities = []) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new InputValidationError('La actividad tiene que ser un número entero positivo. Usá --actividad.');
+    }
+    if (activities.length === 0 || activities.some((activity) => activity.id === value)) {
+        return value;
+    }
+    const prefix = String(value).slice(0, 3);
+    const family = activities.filter((activity) => String(activity.id).startsWith(prefix)).slice(0, 5);
+    const candidates = family.length > 0 ? ` Las que empiezan con ${prefix} son ${family.map((activity) => activity.id).join(', ')}.` : '';
+    throw new InputValidationError(`La actividad ${value} no está en la tabla de actividades de WSFEX y ARCA la rechaza (error 2105).${candidates} Indicá la que corresponda con --actividad.`);
+}
+export function resolveExportType(value) {
+    if (value === undefined) {
+        return DEFAULT_EXPORT_TYPE;
+    }
+    if (!EXPORT_TYPE_VALUES.includes(value)) {
+        throw new InputValidationError('--tipo-expo tiene que ser 1 (exportación definitiva de bienes), 2 (servicios) o 4 (otros).');
+    }
+    return value;
+}
+export function resolveExportLanguage(value, languages) {
+    if (value === undefined) {
+        return DEFAULT_EXPORT_LANGUAGE;
+    }
+    if (languages.length > 0 && !languages.some((language) => language.id === value)) {
+        throw new InputValidationError(`El idioma ${value} no existe en la tabla de ARCA.`);
+    }
+    return value;
+}
+/**
+ * El pais se puede escribir por codigo (`203`) o por nombre (`Brasil`). Se valida contra la tabla de ARCA y
+ * se rechaza Argentina: WSFEX es solo para exportaciones.
+ */
+export function resolveExportDestinationCountry(value, countries) {
+    const trimmed = requireText(value, 'el país de destino', '--pais-destino');
+    const numeric = /^\d+$/.test(trimmed) ? Number(trimmed) : undefined;
+    const country = numeric
+        ? countries.find((entry) => entry.code === numeric)
+        : countries.find((entry) => entry.name.trim().toLowerCase() === trimmed.toLowerCase());
+    if (!country) {
+        throw new InputValidationError(`El país de destino "${trimmed}" no existe en la tabla de ARCA. Usá el código o el nombre que informa ARCA.`);
+    }
+    if (country.code === ARGENTINA_COUNTRY_CODE) {
+        throw new InputValidationError('Argentina no es un destino de exportación: usá `arcli factura a` o `arcli factura b`.');
+    }
+    return country;
+}
+/**
+ * DST_CUIT repite cada pais tres veces, con el tipo de entidad pegado al nombre: "BRASIL - Persona Jurídica".
+ * DST_pais trae solo "BRASIL", asi que el sufijo no sirve para comparar ni para mostrar el pais.
+ */
+const COUNTRY_CUIT_ENTITY_SUFFIX = /\s*-\s*(?:persona\s+f[ií]sica|persona\s+jur[ií]dica|otro\s+tipo\s+de\s+entidad)\s*$/i;
+/** Cuando el pais tiene las tres filas, gana la de persona juridica: el cliente de una exportacion suele ser una empresa. */
+const COUNTRY_CUIT_ENTITY_PREFERENCE = [
+    /\bpersona\s+jur[ií]dica\s*$/i,
+    /\botro\s+tipo\s+de\s+entidad\s*$/i,
+    /\bpersona\s+f[ií]sica\s*$/i,
+];
+/** Para comparar nombres de las dos tablas: sin tipo de entidad, sin acentos, sin mayusculas y con un solo espacio. */
+function normalizeCountryName(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function countryNameWithoutEntity(value) {
+    return value.replace(COUNTRY_CUIT_ENTITY_SUFFIX, '').trim();
+}
+function pickCountryCuit(entries) {
+    for (const preference of COUNTRY_CUIT_ENTITY_PREFERENCE) {
+        const preferred = entries.find((entry) => preference.test(entry.countryName));
+        if (preferred) {
+            return preferred;
+        }
+    }
+    return entries[0];
+}
+/**
+ * WSFEX pide el CUIT del pais del cliente. Se resuelve con la tabla DST_CUIT, que nombra cada pais con el tipo de
+ * entidad ("ESTADOS UNIDOS - Persona Jurídica"), mientras que la tabla de destinos dice solo "ESTADOS UNIDOS": por
+ * eso se compara sin el sufijo. Si el CUIT viene por flag se valida contra la tabla, salvo para los paises cuyo
+ * nombre no coincide entre las dos tablas ("CHINA" y "CHINA REP.POPULAR"), donde solo se acepta que exista.
+ */
+export function resolveExportClientCountryCuit(options) {
+    const destination = normalizeCountryName(options.country.name);
+    const forDestination = options.countries.filter((entry) => normalizeCountryName(countryNameWithoutEntity(entry.countryName)) === destination);
+    if (options.cuit === undefined) {
+        const resolved = pickCountryCuit(forDestination);
+        if (!resolved) {
+            throw new InputValidationError(`La tabla de ARCA no tiene CUIT para "${options.country.name}". Indicalo con --cuit-pais.`);
+        }
+        return resolved.cuit;
+    }
+    const match = options.countries.find((entry) => entry.cuit === options.cuit);
+    if (!match) {
+        throw new InputValidationError(`El CUIT de país ${options.cuit} no existe en la tabla de ARCA.`);
+    }
+    const expected = pickCountryCuit(forDestination);
+    if (expected && normalizeCountryName(countryNameWithoutEntity(match.countryName)) !== destination) {
+        throw new InputValidationError(`El CUIT de país ${options.cuit} corresponde a "${countryNameWithoutEntity(match.countryName)}" y el destino es "${options.country.name}". Para "${options.country.name}" la tabla de ARCA trae ${expected.cuit}.`);
+    }
+    return options.cuit;
+}
+/** `--incoterm` se compara contra la tabla de ARCA, sin importar mayusculas. */
+export function resolveExportIncoterm(value, incoterms) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const incoterm = incoterms.find((entry) => entry.code.trim().toUpperCase() === trimmed.toUpperCase());
+    if (!incoterm) {
+        throw new InputValidationError(`El incoterm "${trimmed}" no existe en la tabla de ARCA. Consultá los válidos con arcli parametros.`);
+    }
+    return incoterm;
+}
+export function resolveExportPointOfSale(value, config) {
+    const pointOfSale = value ?? config.puntoVentaPorDefecto;
+    if (pointOfSale === undefined) {
+        throw new InputValidationError('Falta el punto de venta. Usá --punto-venta o configurá puntoVentaPorDefecto.');
+    }
+    if (!Number.isInteger(pointOfSale) || pointOfSale < 1) {
+        throw new InputValidationError('El punto de venta tiene que ser un número entero positivo.');
+    }
+    return pointOfSale;
+}
+/** Numero del comprobante o de la solicitud: el indicado por el usuario o el que sigue al ultimo de ARCA. */
+export function resolveExportNumber(options) {
+    if (options.provided !== undefined) {
+        if (!Number.isInteger(options.provided) || options.provided < 1) {
+            throw new InputValidationError(`${options.label} tiene que ser un número entero positivo.`);
+        }
+        return options.provided;
+    }
+    const next = (Number.isFinite(options.last) ? options.last : 0) + 1;
+    if (next > MAX_EXPORT_VOUCHER_NUMBER) {
+        throw new InputValidationError(`${options.label} supera el máximo de ARCA (${MAX_EXPORT_VOUCHER_NUMBER}).`);
+    }
+    return next;
+}
+/** En los tipos 2 (servicios) y 4 (otros) ARCA exige `Permiso_existente` vacio, no `N` (error 1550). */
+function requiresEmptyPermitsExisting(exportType) {
+    return EXPORT_TYPES_WITHOUT_PERMITS.includes(exportType);
+}
+/**
+ * Con `Permiso_existente = N` ARCA rechaza el campo `Permisos` (error 1720), y en los tipos 2 y 4 pide el campo
+ * vacio y no admite permisos (error 1550): sin permisos no se manda.
+ */
+function resolvePermits(input, destinationCountry, exportType) {
+    const permits = (input.permits ?? []).map((permit) => permit.trim()).filter(Boolean);
+    if (permits.length === 0) {
+        if (input.permitsExisting) {
+            throw new InputValidationError('--permiso-existente pide al menos un permiso de embarque. Usá --permiso.');
+        }
+        return undefined;
+    }
+    if (requiresEmptyPermitsExisting(exportType)) {
+        throw new InputValidationError(`El tipo de exportación ${exportType} (${EXPORT_TYPES[exportType]}) no lleva permisos de embarque: ARCA exige Permiso_existente vacío (error 1550). Quitá --permiso.`);
+    }
+    if (!input.permitsExisting) {
+        throw new InputValidationError('Los permisos de embarque van con --permiso-existente: ARCA necesita saber que el permiso ya existe.');
+    }
+    return { Permiso: [...new Set(permits)].map((id) => ({ Dst_merc: destinationCountry, Id_permiso: id })) };
+}
+/**
+ * Arma el `Cmp` de `FEXAuthorize` con los datos ya resueltos contra las tablas de ARCA.
+ *
+ * Los bloques vacios no van: `Permisos` sin permisos (error 1720), `Cmps_asoc` y `Opcionales` sin filas (error 1820
+ * el primero). `Actividades`, en cambio, siempre lleva una `Actividad` (error 2100).
+ */
+export function buildExportPayload(input, resolution) {
+    const clientName = requireText(input.clientName, 'el nombre del cliente', '--cliente');
+    const clientAddress = requireText(input.clientAddress, 'el domicilio del cliente', '--domicilio-cliente');
+    if (typeof input.amount !== 'number' || !(input.amount > 0)) {
+        throw new InputValidationError('Falta el importe total o no es válido. Usá --monto.');
+    }
+    const permits = resolvePermits(input, resolution.destinationCountry.code, resolution.exportType);
+    /** En servicios y otros ARCA pide el campo vacio; en el resto, `N` sin permisos y `S` con permisos. */
+    const permitsExisting = requiresEmptyPermitsExisting(resolution.exportType)
+        ? ''
+        : input.permitsExisting
+            ? 'S'
+            : 'N';
+    return {
+        // Actividades va siempre con una: con el bloque vacio ARCA contesta 2100.
+        Actividades: { Actividad: [{ Id: resolution.activity }] },
+        CanMisMonExt: resolution.currency.CanMisMonExt,
+        Cbte_nro: resolution.voucherNumber,
+        Cbte_Tipo: EXPORT_VOUCHER_KIND.arcaType,
+        Cliente: clientName,
+        Cuit_pais_cliente: resolution.clientCountryCuit,
+        Domicilio_cliente: clientAddress,
+        Dst_cmp: resolution.destinationCountry.code,
+        Fecha_cbte: resolution.voucherDate,
+        Fecha_pago: resolution.paymentDate,
+        Forma_pago: input.paymentTerms?.trim() || DEFAULT_EXPORT_PAYMENT_TERMS,
+        Id: resolution.requestId,
+        Id_impositivo: input.clientTaxId?.trim() ?? '',
+        Idioma_cbte: resolution.languageId,
+        Imp_total: roundAmount(input.amount),
+        Incoterms: resolution.incoterm?.code ?? '',
+        Incoterms_Ds: input.incotermDescription?.trim() || resolution.incoterm?.name || '',
+        Items: { Item: [...resolution.items] },
+        Moneda_ctz: resolution.currency.Moneda_ctz,
+        Moneda_Id: resolution.currency.Moneda_Id,
+        Obs: input.observations?.trim() ?? '',
+        Obs_comerciales: input.commercialObservations?.trim() ?? '',
+        Permiso_existente: permitsExisting,
+        ...(permits ? { Permisos: permits } : {}),
+        Punto_vta: resolution.pointOfSale,
+        Tipo_expo: resolution.exportType,
+    };
+}

package/dist/modules/export/export.presenter.js

@@ -0,0 +1,2 @@
+export { formatExportResultAsJson } from './export.serialize.js';
+export { formatExportResultAsText } from './export.text.js';

package/dist/modules/export/export.response.js

@@ -0,0 +1,86 @@
+const POINT_OF_SALE_HINT = 'Revisá los puntos de venta habilitados para WSFEX con `arcli parametros puntos-venta`.';
+function normalizeArcaDate(value) {
+    const digits = (value ?? '').replace(/\D/g, '').slice(0, 8);
+    return /^\d{8}$/.test(digits) ? digits : null;
+}
+/**
+ * WSFEX informa los errores en `FEXErr` y los avisos en `FEXEvents`, con el codigo en 0 cuando no hay nada que
+ * decir: en la autorizacion exitosa manda `ErrCode: 0` con `ErrMsg: "OK"`, que no es un error.
+ */
+function toEntry(code, message) {
+    if (!code) {
+        return [];
+    }
+    return [{ code, message: message?.trim() || 'ARCA no informó el detalle.' }];
+}
+function buildSuggestions(options) {
+    const suggestions = new Set();
+    if (/punto de venta/i.test(options.messages)) {
+        suggestions.add(POINT_OF_SALE_HINT);
+    }
+    if (/permiso/i.test(options.messages)) {
+        suggestions.add('Revisá los permisos de embarque: van con --permiso y --permiso-existente.');
+    }
+    if (/cuit.*(pais|país)/i.test(options.messages)) {
+        suggestions.add('Revisá el CUIT del país del cliente (`--cuit-pais`) y el país de destino.');
+    }
+    if (/moneda|cotizaci[oó]n/i.test(options.messages)) {
+        suggestions.add('Revisá la moneda y la cotización (`--moneda`, `--cotizacion-moneda`).');
+    }
+    if (/incoterm/i.test(options.messages)) {
+        suggestions.add('Revisá el incoterm (`--incoterm`) contra la tabla de ARCA.');
+    }
+    if (/actividad/i.test(options.messages)) {
+        suggestions.add('La actividad tiene que estar vinculada al emisor y activa para WSFEX: revisá las actividades habilitadas en ARCA o indicá otra con --actividad.');
+    }
+    if (/correlativ/i.test(options.messages)) {
+        suggestions.add('Revisá el número del comprobante (--numero): tiene que ser el siguiente al último E emitido en ese punto de venta.');
+    }
+    if (options.status !== 'aprobado' && suggestions.size === 0) {
+        suggestions.add('Revisá observaciones y errores de ARCA antes de volver a emitir.');
+    }
+    return [...suggestions];
+}
+export function createDryRunExportResponse() {
+    return {
+        cae: null,
+        caeVencimiento: null,
+        errors: [],
+        events: [],
+        observacion: null,
+        observaciones: [],
+        raw: null,
+        resultado: null,
+        status: 'observado',
+        suggestions: [],
+    };
+}
+/** WSFEX informa el rechazo en `Resultado` y los errores duros en `FEXErr`, sin lanzar excepcion. */
+export function mapExportResponse(output) {
+    const result = output.FEXAuthorizeResult;
+    const authorization = result?.FEXResultAuth;
+    const errors = toEntry(result?.FEXErr?.ErrCode, result?.FEXErr?.ErrMsg);
+    const events = toEntry(result?.FEXEvents?.EventCode, result?.FEXEvents?.EventMsg);
+    const motivo = authorization?.Motivos_Obs?.trim();
+    const observaciones = motivo ? [motivo] : [];
+    const resultado = authorization?.Resultado?.trim() || null;
+    const cae = authorization?.Cae?.trim() || null;
+    const status = resultado === 'R' || errors.length > 0
+        ? 'rechazado'
+        : resultado === 'A' && observaciones.length === 0
+            ? 'aprobado'
+            : 'observado';
+    const messages = [...observaciones, ...errors.map((error) => error.message)].join(' | ');
+    return {
+        cae,
+        caeVencimiento: normalizeArcaDate(authorization?.Fch_venc_Cae),
+        errors,
+        events,
+        observacion: observaciones.join(' | ') || null,
+        observaciones,
+        raw: output,
+        resultado,
+        status,
+        suggestions: buildSuggestions({ messages, status }),
+    };
+}

package/dist/modules/export/export.serialize.js

@@ -0,0 +1,70 @@
+// Aditivo: la clave `pdf` solo aparece si se intento generar el PDF.
+function formatPdfOutcome(result) {
+    if (!result.pdf) {
+        return {};
+    }
+    if ('path' in result.pdf) {
+        return { pdf: { ruta: result.pdf.path } };
+    }
+    const { code, message, suggestion } = result.pdf.error;
+    return { pdf: { error: { codigo: code, mensaje: message, sugerencia: suggestion ?? null } } };
+}
+function formatRawResponse(result) {
+    return result.response.raw ?? { mensaje: 'Sin emisión real. Usá --emitir para obtener una respuesta de ARCA.' };
+}
+/** Lo que WSFEX tiene y wsfe no: destino, incoterm, permisos e items reales. */
+function formatExportBlock(result) {
+    const { payload, display } = result;
+    return {
+        actividad: payload.Actividades.Actividad.map((activity) => activity.Id),
+        cliente: payload.Cliente,
+        cuitPaisCliente: payload.Cuit_pais_cliente,
+        destino: { codigo: payload.Dst_cmp, nombre: display.countryName ?? null },
+        domicilioCliente: payload.Domicilio_cliente,
+        formaPago: payload.Forma_pago,
+        idImpositivo: payload.Id_impositivo || null,
+        idioma: payload.Idioma_cbte,
+        incoterm: payload.Incoterms || null,
+        incotermDescripcion: payload.Incoterms_Ds || null,
+        items: payload.Items.Item.map((item) => ({
+            cantidad: item.Pro_qty,
+            codigo: item.Pro_codigo || null,
+            descripcion: item.Pro_ds,
+            precioUnitario: item.Pro_precio_uni,
+            total: item.Pro_total_item,
+            unidad: display.unitNames[item.Pro_umed] ?? null,
+            unidadCodigo: item.Pro_umed,
+        })),
+        mismaMoneda: payload.CanMisMonExt === 'S',
+        permisos: payload.Permisos?.Permiso ?? [],
+        tipoExpo: payload.Tipo_expo,
+    };
+}
+export function serializeExportResult(result, options = {}) {
+    const summary = {
+        atajo: result.voucherKind.shortcut,
+        avisos: result.warnings ?? [],
+        cae: result.response.cae,
+        caeVencimiento: result.response.caeVencimiento,
+        comprobante: result.voucherKind.displayName,
+        errores: result.response.errors,
+        estado: result.response.status,
+        eventos: result.response.events,
+        exportacion: formatExportBlock(result),
+        observaciones: result.response.observaciones,
+        observacion: result.response.observacion,
+        ...formatPdfOutcome(result),
+        previsualizacion: result.dryRun,
+        resultado: result.response.resultado,
+        solicitud: result.payload,
+        sugerencias: result.response.suggestions,
+        tipoArca: result.voucherKind.arcaType,
+    };
+    return options.raw ? { ...summary, respuesta: formatRawResponse(result) } : summary;
+}
+export function formatExportResultAsJson(result, options = {}) {
+    return JSON.stringify(serializeExportResult(result, options), null, 2);
+}
+export function formatRawExportResponse(result) {
+    return formatRawResponse(result);
+}

package/dist/modules/export/export.service.js

@@ -0,0 +1,146 @@
+import { formatArcaDateAsArgentineDate, formatDateAsArcaDate, parseArgentineDateInputAsArcaDate, } from '../../lib/dates/arca-date.js';
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { assertExportItemsTotal, buildExportItems, DEFAULT_EXPORT_ITEM_DESCRIPTION } from './export.items.js';
+import { buildExportPayload, resolveExportActivity, resolveExportClientCountryCuit, resolveExportCurrency, resolveExportDestinationCountry, resolveExportIncoterm, resolveExportLanguage, resolveExportNumber, resolveExportPointOfSale, resolveExportQuotation, resolveExportType, resolveExportVoucherDate, } from './export.mappers.js';
+import { createDryRunExportResponse, mapExportResponse } from './export.response.js';
+import { EXPORT_VOUCHER_KIND, } from './export.types.js';
+/** Se valida antes de tocar la red: un flag que falta no tiene por que autenticar en WSAA. */
+function assertRequiredFields(input, activity) {
+    if (typeof input.amount !== 'number' || !(input.amount > 0)) {
+        throw new InputValidationError('Falta el importe total o no es válido. Usá --monto.');
+    }
+    if (!input.clientName?.trim()) {
+        throw new InputValidationError('Falta el nombre del cliente. Usá --cliente.');
+    }
+    if (!input.clientAddress?.trim()) {
+        throw new InputValidationError('Falta el domicilio del cliente. Usá --domicilio-cliente.');
+    }
+    if (!input.destinationCountry?.trim()) {
+        throw new InputValidationError('Falta el país de destino. Usá --pais-destino.');
+    }
+    // WSFEX numera por punto de venta y tipo, pero @arcasdk/core no deja consultar el ultimo (FEXGetLast_CMP lleva
+    // Pto_venta y Cbte_Tipo dentro de Auth y el SDK pisa ese bloque). Hasta que se arregle, el numero lo indica el usuario.
+    if (input.voucherNumber === undefined) {
+        throw new InputValidationError('Falta el número del comprobante. Usá --numero: arcli todavía no puede consultar en WSFEX el último emitido. Si es la primera Factura E de este punto de venta, es 1; si no, el siguiente al último que emitiste.');
+    }
+    if (activity === undefined) {
+        throw new InputValidationError('Falta la actividad de exportación. Usá --actividad o guardala con "arcli config establecer exportacion.actividad <código>": es el código de la tabla de actividades de WSFEX, por ejemplo 620100.');
+    }
+    assertExportItemsTotal(input.items, input.amount);
+}
+/** WSFEX no acepta comprobantes con fecha futura. Las fechas pasadas si son validas. */
+function assertNotFuture(voucherDate, now) {
+    const today = formatDateAsArcaDate(now);
+    if (voucherDate > today) {
+        throw new InputValidationError(`La fecha del comprobante (${voucherDate.slice(6, 8)}/${voucherDate.slice(4, 6)}/${voucherDate.slice(0, 4)}) no puede ser futura.`);
+    }
+}
+export class ExportService {
+    /**
+     * Resuelve todo lo que pide WSFEX antes de emitir: tablas de paises, incoterms, idiomas y unidades,
+     * numeracion y cotizacion. Son llamadas de lectura: no emiten nada.
+     */
+    async resolve(input, gateway, runtime, now = new Date()) {
+        const config = runtime.config;
+        const activityCode = input.activity ?? config.exportacion?.actividad;
+        assertRequiredFields(input, activityCode);
+        const exportType = resolveExportType(input.exportType);
+        const voucherDate = resolveExportVoucherDate(input.voucherDate, now);
+        const paymentDate = input.paymentDate?.trim() ? parseArgentineDateInputAsArcaDate(input.paymentDate) : voucherDate;
+        assertNotFuture(voucherDate, now);
+        const countryList = await gateway.getDestinationCountries();
+        const destinationCountry = resolveExportDestinationCountry(input.destinationCountry, countryList);
+        const countryCuits = await gateway.getDestinationCountryCuits();
+        const clientCountryCuit = resolveExportClientCountryCuit({
+            country: destinationCountry,
+            countries: countryCuits,
+            cuit: input.clientCountryCuit,
+        });
+        const units = await gateway.getUnits();
+        const items = buildExportItems(input.items, input.amount, units, input.description?.trim() || DEFAULT_EXPORT_ITEM_DESCRIPTION);
+        const incoterm = resolveExportIncoterm(input.incoterm, input.incoterm?.trim() ? await gateway.getIncoterms() : []);
+        // Se consulta siempre: la vista previa muestra el nombre del idioma, tambien el de por defecto.
+        const languages = await gateway.getLanguages();
+        const languageId = resolveExportLanguage(input.language, languages);
+        const currency = resolveExportCurrency(input);
+        const quotation = currency.needsQuotation
+            ? resolveExportQuotation(currency.fields.Moneda_Id, await gateway.getQuotations(voucherDate), voucherDate)
+            : undefined;
+        const exchangeRate = quotation?.rate ?? currency.fields.Moneda_ctz;
+        const pointOfSale = resolveExportPointOfSale(input.pointOfSale, config);
+        const voucherNumber = resolveExportNumber({
+            label: 'El número del comprobante',
+            last: 0,
+            provided: input.voucherNumber,
+        });
+        const requestId = resolveExportNumber({
+            label: 'El ID de la solicitud',
+            last: input.requestId === undefined ? await gateway.getLastRequestId() : 0,
+            provided: input.requestId,
+        });
+        const activity = resolveExportActivity(activityCode, await gateway.getActivities());
+        const payload = buildExportPayload(input, {
+            activity,
+            clientCountryCuit,
+            currency: {
+                ...currency.fields,
+                Moneda_Id: quotation?.code ?? currency.fields.Moneda_Id,
+                Moneda_ctz: exchangeRate,
+            },
+            destinationCountry,
+            exportType,
+            incoterm,
+            items: items.items,
+            languageId,
+            paymentDate,
+            pointOfSale,
+            requestId,
+            voucherDate,
+            voucherNumber,
+        });
+        const currencyCode = payload.Moneda_Id.trim().toUpperCase();
+        const display = {
+            countryCuitName: countryCuits.find((entry) => entry.cuit === clientCountryCuit)?.countryName,
+            countryName: destinationCountry.name,
+            currencyName: (await gateway.getCurrencies()).find((entry) => entry.code.trim().toUpperCase() === currencyCode)
+                ?.name,
+            incotermName: incoterm?.name,
+            languageName: languages.find((language) => language.id === languageId)?.name,
+            unitNames: Object.fromEntries(units.map((unit) => [unit.id, unit.name])),
+        };
+        // La cotizacion de aduana del dia se publica mas tarde: se emite con la ultima disponible, avisando de que dia es.
+        const warnings = [
+            ...(quotation?.date && quotation.date !== voucherDate
+                ? [
+                    `ARCA no publicó la cotización de ${quotation.code} del ${formatArcaDateAsArgentineDate(voucherDate)}: se usa la del ${formatArcaDateAsArgentineDate(quotation.date)} (${quotation.rate}). Para usar otra, --cotizacion-moneda.`,
+                ]
+                : []),
+        ];
+        return { display, payload, warnings };
+    }
+    /** Vista previa: el payload resuelto, sin llamar a `authorize`. */
+    preview(resolved, runtime, warnings) {
+        return {
+            display: resolved.display,
+            dryRun: true,
+            environment: runtime.environment,
+            payload: resolved.payload,
+            response: createDryRunExportResponse(),
+            voucherKind: EXPORT_VOUCHER_KIND,
+            warnings,
+        };
+    }
+    /** La llamada que emite. Un error aca puede haber dejado el comprobante autorizado en ARCA. */
+    async execute(options) {
+        const raw = await options.gateway.authorize(options.resolved.payload);
+        return {
+            display: options.resolved.display,
+            dryRun: false,
+            environment: options.runtime.environment,
+            payload: options.resolved.payload,
+            response: mapExportResponse(raw),
+            voucherKind: EXPORT_VOUCHER_KIND,
+            warnings: options.warnings,
+        };
+    }
+}