arcli 2.1.0 → 2.2.1

package/dist/modules/examples/examples.js

@@ -1,7 +1,8 @@
 import { toArgentineCalendarDate } from '../../lib/dates/arca-date.js';
 import { badge, renderLogo, sectionHeading, toneText } from '../../ui/index.js';
 import { VOUCHER_FAMILIES, VOUCHER_KIND_MAP, VOUCHER_SHORTCUTS } from '../billing/voucher-kind-map.js';
-const ISSUER_HINT = 'Estos ejemplos asumen que ya resolviste cuit emisor, credenciales y, en la version minima, tambien punto de venta por config.';
+import { EXPORT_VOUCHER_KIND } from '../export/export.types.js';
+const ISSUER_HINT = 'Estos ejemplos asumen que ya resolviste cuit emisor, credenciales y, en la versión mínima, también punto de venta por config.';
 function resolveAmount(definition) {
     if (definition.letter === 'a') {
         return 1;
@@ -37,7 +38,7 @@ function resolveAssociatedFlags(definition, form) {
         `--ac ${resolveAssociatedShortcut(definition)}`,
         form === 'long' ? '--asociado-punto-venta 3' : '--apv 3',
         '--ar 120',
-        ...(definition.isElectronicCredit ? [] : ['--acuit 20409509763']),
+        ...(definition.isElectronicCredit ? [] : ['--acuit 20333333334']),
     ];
 }
 function formatExampleDate(value) {
@@ -134,10 +135,10 @@ function formatVoucherExample(definition, dates) {
     return [
         sectionHeading(definition.displayName),
         '',
-        `${badge('MINIMA LARGA', 'info')}`,
+        `${badge('MÍNIMA LARGA', 'info')}`,
         `${buildMinimalLong(definition, dates)} --previsualizar`,
         '',
-        `${badge('MINIMA CORTA', 'success')}`,
+        `${badge('MÍNIMA CORTA', 'success')}`,
         `${buildMinimalShort(definition, dates)} --previsualizar`,
         '',
         `${badge('FULL LARGA', 'warning')}`,
@@ -153,6 +154,36 @@ function renderFamilyExamples(family, dates) {
         .map((definition) => formatVoucherExample(definition, dates))
         .join('\n\n\n');
 }
+const EXPORT_CLIENT = '--cliente "ACME LLC" --domicilio-cliente "123 Main St" --pais-destino 212 --numero 1';
+/** El comando minimo de la factura E por shortcut, sin modo de ejecucion. Lo usa tambien la ayuda de `fe`. */
+export const EXPORT_MINIMAL_EXAMPLE = `arcli ${EXPORT_VOUCHER_KIND.shortcut} -m 1500 ${EXPORT_CLIENT} --actividad 620100`;
+/** La E no comparte flags de receptor ni de IVA con A, B y C: sus ejemplos se arman aparte. */
+function formatExportExample() {
+    const { family, letter, shortcut } = EXPORT_VOUCHER_KIND;
+    const fullFlags = [
+        '--id-impositivo "12-3456789"',
+        '--tipo-expo 2',
+        '--item "001|Servicios de consultoría|10|150|unidades"',
+        '--fecha-pago 15/11',
+        '--forma-pago "Transferencia Internacional"',
+        '--obs-comerciales "Orden de compra 778"',
+    ];
+    return [
+        sectionHeading(EXPORT_VOUCHER_KIND.displayName),
+        '',
+        `${badge('MÍNIMA LARGA', 'info')}`,
+        `arcli ${family} ${letter} --monto 1500 ${EXPORT_CLIENT} --actividad 620100 --previsualizar`,
+        '',
+        `${badge('MÍNIMA CORTA', 'success')}`,
+        `${EXPORT_MINIMAL_EXAMPLE} --previsualizar`,
+        '',
+        `${badge('FULL LARGA', 'warning')}`,
+        `arcli ${family} ${letter} --monto 1500 ${EXPORT_CLIENT} --actividad 620100 ${fullFlags.join(' ')} --moneda USD --misma-moneda --previsualizar`,
+        '',
+        `${badge('FULL CORTA', 'debug')}`,
+        `arcli ${shortcut} -m 1500 ${EXPORT_CLIENT} --actividad 620100 ${fullFlags.join(' ')} --mda USD --misma-moneda --previsualizar`,
+    ].join('\n');
+}
 /** El comando minimo por shortcut (`arcli nca -m 1 --cs ...`), sin modo de ejecucion. Lo usa tambien la ayuda. */
 export function buildMinimalShortcutExample(definition, today = new Date()) {
     return buildMinimalShort(definition, resolveExampleDates(today));
@@ -166,21 +197,24 @@ export function renderExamples(today = new Date()) {
     return [
         renderLogo().trim(),
         '',
-        `${badge('MINIMA', 'info')} datos esenciales`,
-        `${badge('FULL', 'warning')} mas campos explicitados`,
+        `${badge('MÍNIMA', 'info')} datos esenciales`,
+        `${badge('FULL', 'warning')} más campos explicitados`,
         `${badge('LARGA', 'success')} comando largo`,
         `${badge('CORTA', 'debug')} shortcut y aliases`,
         '',
         toneText('SEGURIDAD', 'warning'),
         'Todos usan --previsualizar para evitar emisiones reales por error.',
-        'Si queres emitir de verdad, reemplaza --previsualizar por --emitir.',
-        'Para emitir en produccion necesitas --produccion junto con --emitir.',
+        'Si querés emitir de verdad, reemplaza --previsualizar por --emitir.',
+        'Para emitir en producción necesitas --produccion junto con --emitir.',
         'Para guardar el PDF con el QR, agrega --exportar-pdf al emitir (ver docs/pdf.md).',
         '',
         ISSUER_HINT,
         '',
-        ...VOUCHER_FAMILIES.flatMap((family) => [renderFamilyExamples(family, dates), '']),
+        ...VOUCHER_FAMILIES.flatMap((family) => [
+            renderFamilyExamples(family, dates),
+            ...(family === EXPORT_VOUCHER_KIND.family ? ['', '', formatExportExample()] : []),
+            '',
+        ]),
         '',
     ].join('\n');
 }
-//# sourceMappingURL=examples.js.map

package/dist/modules/export/export.items.js

@@ -0,0 +1,149 @@
+import Big from 'big.js';
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { parseArgentineAmount } from '../../lib/numbers/argentine-amount.js';
+import { DEFAULT_EXPORT_UNIT_CODE, } from './export.types.js';
+export const DEFAULT_EXPORT_ITEM_DESCRIPTION = 'Según detalle';
+const ITEM_FORMAT_HINT = 'Usá --item "codigo|descripcion|cantidad|precio|unidad" (el código y la unidad son opcionales).';
+function parseItemAmount(part, field, raw) {
+    const parsed = parseArgentineAmount(part, { maxDecimals: 6 });
+    if (!parsed.ok) {
+        throw new InputValidationError(`El ${field} del item "${raw}" no es válido: ${parsed.reason}.`);
+    }
+    return parsed.value;
+}
+/**
+ * Un item por flag. Se separa con `|` para no pelear con las comas de los importes:
+ * `001|Servicio de consultoria|1|1000|unidad`. Con cuatro partes se omite el codigo y con tres la unidad.
+ */
+export function parseExportItemArgument(raw) {
+    const parts = raw.split('|').map((part) => part.trim());
+    if (parts.length < 3 || parts.length > 5) {
+        throw new InputValidationError(`El item "${raw}" no es válido. ${ITEM_FORMAT_HINT}`);
+    }
+    const [codeOrDescription, ...rest] = parts;
+    const description = parts.length === 5 ? rest.shift() : codeOrDescription;
+    const [quantityPart, pricePart, unitPart] = rest;
+    if (!description || !quantityPart || !pricePart) {
+        throw new InputValidationError(`El item "${raw}" no es válido: falta la descripción, la cantidad o el precio.`);
+    }
+    return {
+        code: parts.length === 5 ? codeOrDescription : undefined,
+        description,
+        quantity: parseItemAmount(quantityPart, 'la cantidad', raw),
+        unit: unitPart ? resolveExportItemUnit(unitPart) : DEFAULT_EXPORT_UNIT_CODE,
+        unitPrice: parseItemAmount(pricePart, 'el precio', raw),
+    };
+}
+/** La unidad del item puede ser el codigo de ARCA (`7`) o el nombre de la tabla (`unidad`). */
+export function resolveExportItemUnit(unit) {
+    if (typeof unit === 'number') {
+        return unit;
+    }
+    const trimmed = unit.trim();
+    if (!trimmed) {
+        throw new InputValidationError('La unidad del item no puede estar vacía. Usá --item sin la última parte para usar "unidad".');
+    }
+    return /^\d+$/.test(trimmed) ? Number(trimmed) : trimmed;
+}
+/**
+ * La tabla de ARCA escribe las unidades en plural ("unidades", "kilogramos") y los ejemplos del CLI en singular
+ * ("unidad"): se aceptan las dos formas, sin inventar codigos para nombres que no estan en la tabla.
+ */
+function singularUnitName(value) {
+    if (/[dlrnz]es$/.test(value)) {
+        return value.slice(0, -2);
+    }
+    return value.endsWith('s') ? value.slice(0, -1) : value;
+}
+function findUnitByName(units, normalized) {
+    const exact = units.find((entry) => entry.name.trim().toLowerCase() === normalized);
+    if (exact) {
+        return exact;
+    }
+    const singular = singularUnitName(normalized);
+    const matches = units.filter((entry) => singularUnitName(entry.name.trim().toLowerCase()) === singular);
+    return matches.length === 1 ? matches[0] : undefined;
+}
+/**
+ * Codigo de ARCA de la unidad: si viene un nombre se busca en la tabla de WSFEX. Un nombre desconocido
+ * es un error, no un default silencioso.
+ */
+export function resolveUnitCode(unit, units) {
+    if (typeof unit === 'number') {
+        const known = units.find((entry) => entry.id === unit);
+        if (units.length > 0 && !known) {
+            throw new InputValidationError(`La unidad ${unit} no existe en la tabla de ARCA.`);
+        }
+        return unit;
+    }
+    if (typeof unit === 'string') {
+        const match = findUnitByName(units, unit.trim().toLowerCase());
+        if (match) {
+            return match.id;
+        }
+        throw new InputValidationError(`La unidad "${unit}" no existe en la tabla de ARCA. Usá el nombre tal como lo informa ARCA o el código numérico.`);
+    }
+    return DEFAULT_EXPORT_UNIT_CODE;
+}
+function roundAmount(value) {
+    return value.round(2, Big.roundHalfUp).toNumber();
+}
+function assertSameTotal(total, amount) {
+    if (!total.eq(new Big(amount).round(2, Big.roundHalfUp))) {
+        throw new InputValidationError(`La suma de los items (${roundAmount(total).toFixed(2)}) no coincide con --monto (${amount.toFixed(2)}).`);
+    }
+}
+/** Se valida antes de consultar ARCA: un total que no cierra no tiene por que autenticar en WSAA. */
+export function assertExportItemsTotal(inputs, amount) {
+    if (!inputs || inputs.length === 0) {
+        return;
+    }
+    const total = inputs.reduce((sum, item) => sum.plus(new Big(item.quantity).times(item.unitPrice).round(2, Big.roundHalfUp)), new Big(0));
+    assertSameTotal(total, amount);
+}
+/**
+ * Un item sin `--item` resume el comprobante en un renglon con el total. Con items, la suma tiene que dar
+ * el monto: ARCA no valida `Imp_total` contra los items, asi que se valida aca.
+ */
+export function buildExportItems(inputs, amount, units, defaultDescription) {
+    if (!inputs || inputs.length === 0) {
+        return {
+            items: [
+                {
+                    Pro_bonificacion: 0,
+                    Pro_codigo: '',
+                    Pro_ds: defaultDescription,
+                    Pro_precio_uni: amount,
+                    Pro_qty: 1,
+                    Pro_total_item: roundAmount(new Big(amount)),
+                    Pro_umed: DEFAULT_EXPORT_UNIT_CODE,
+                },
+            ],
+            total: roundAmount(new Big(amount)),
+        };
+    }
+    const items = inputs.map((item) => {
+        if (!item.description.trim()) {
+            throw new InputValidationError('Cada item necesita una descripción.');
+        }
+        const quantity = new Big(item.quantity);
+        if (quantity.lte(0)) {
+            throw new InputValidationError(`La cantidad del item "${item.description}" tiene que ser mayor a 0.`);
+        }
+        if (!(item.unitPrice > 0)) {
+            throw new InputValidationError(`El precio del item "${item.description}" tiene que ser mayor a 0.`);
+        }
+        return {
+            Pro_bonificacion: 0,
+            Pro_codigo: item.code?.trim() ?? '',
+            Pro_ds: item.description.trim(),
+            Pro_precio_uni: item.unitPrice,
+            Pro_qty: quantity.toNumber(),
+            Pro_total_item: roundAmount(quantity.times(item.unitPrice)),
+            Pro_umed: resolveUnitCode(item.unit, units),
+        };
+    });
+    const total = items.reduce((sum, item) => sum.plus(item.Pro_total_item), new Big(0));
+    assertSameTotal(total, amount);
+    return { items, total: roundAmount(total) };
+}

package/dist/modules/export/export.json-input.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { InputValidationError } from '../../lib/errors/app-error.js';
+const itemJsonSchema = z
+    .object({
+    cantidad: z.number(),
+    codigo: z.string().optional(),
+    descripcion: z.string(),
+    precioUnitario: z.number(),
+    unidad: z.union([z.string(), z.number()]).optional(),
+})
+    .strict();
+/**
+ * Forma del JSON de `--cargar`: solo tipos y claves. Los valores (importes, pais, incoterm) los valida el
+ * servicio igual que si vinieran por flags. Es `.strict()` para que un typo no se ignore en silencio.
+ */
+export const exportJsonInputSchema = z
+    .object({
+    actividad: z.number().optional(),
+    cliente: z.string().optional(),
+    codigoMoneda: z.string().optional(),
+    cotizacionMoneda: z.number().optional(),
+    cuitPais: z.number().optional(),
+    descripcion: z.string().optional(),
+    descripcionIncoterm: z.string().optional(),
+    domicilioCliente: z.string().optional(),
+    emitir: z.boolean().optional(),
+    fechaComprobante: z.string().optional(),
+    fechaPago: z.string().optional(),
+    formaPago: z.string().optional(),
+    idImpositivo: z.string().optional(),
+    idSolicitud: z.number().optional(),
+    idioma: z.number().optional(),
+    incoterm: z.string().optional(),
+    items: z.array(itemJsonSchema).optional(),
+    mismaMoneda: z.boolean().optional(),
+    monto: z.number().optional(),
+    numero: z.number().optional(),
+    observaciones: z.string().optional(),
+    observacionesComerciales: z.string().optional(),
+    paisDestino: z.union([z.string(), z.number()]).optional(),
+    pdf: z.boolean().optional(),
+    permisoExistente: z.boolean().optional(),
+    permisos: z.array(z.string()).optional(),
+    puntoVenta: z.number().optional(),
+    previsualizar: z.boolean().optional(),
+    tipoExpo: z.union([z.literal(1), z.literal(2), z.literal(4)]).optional(),
+})
+    .strict();
+const TYPE_LABELS = {
+    array: 'un array',
+    boolean: 'true o false',
+    number: 'un número',
+    object: 'un objeto',
+    string: 'un texto',
+};
+function describeIssue(issue) {
+    const path = issue.path.map(String).join('.');
+    if (issue.code === 'unrecognized_keys') {
+        return `La clave "${issue.keys.join('", "')}" no existe en el JSON de --cargar.`;
+    }
+    if (issue.code === 'invalid_type' && issue.input === undefined) {
+        return `Falta "${path}".`;
+    }
+    if (issue.code === 'invalid_type') {
+        return `"${path}" tiene que ser ${TYPE_LABELS[issue.expected] ?? issue.expected}.`;
+    }
+    return path ? `"${path}": ${issue.message}.` : `${issue.message}.`;
+}
+export function parseExportJsonInput(value) {
+    const result = exportJsonInputSchema.safeParse(value, { reportInput: true });
+    if (result.success) {
+        return result.data;
+    }
+    throw new InputValidationError(`En el JSON de --cargar: ${result.error.issues.map((issue) => describeIssue(issue)).join(' ')}`);
+}
+/** `--cargar` toma un solo comprobante; el lote de exportacion queda para mas adelante. */
+export function readExportJsonInput(source) {
+    if (Array.isArray(source)) {
+        throw new InputValidationError('El JSON de --cargar de la factura E tiene que ser un objeto con un comprobante, no un array.');
+    }
+    return parseExportJsonInput(source);
+}
+export function mapExportJsonItems(items) {
+    return items?.map((item) => ({
+        code: item.codigo,
+        description: item.descripcion,
+        quantity: item.cantidad,
+        unit: item.unidad,
+        unitPrice: item.precioUnitario,
+    }));
+}

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';