arcli 2.0.0 → 2.2.0

package/dist/cli/commands/billing.command.shortcuts.js

@@ -14,7 +14,7 @@ export function resolveIvaShortcut(commandOptions) {
         commandOptions.irSnc ? 'sujeto-no-categorizado' : null,
     ].filter(Boolean);
     if (shortcuts.length > 1) {
-        throw new InputValidationError('Use solo un flag de IVA receptor entre las opciones --ir-*.');
+        throw new InputValidationError('Usá solo un flag de IVA receptor entre las opciones --ir-*.');
     }
     return shortcuts[0];
 }
@@ -34,7 +34,7 @@ export function resolveDocumentIdentity(commandOptions) {
             : null,
     ].filter(Boolean);
     if (candidates.length > 1) {
-        throw new InputValidationError('Use solo una identidad de receptor: --cuit, --cuil, --dni, --consumidor-final o --cfinal.');
+        throw new InputValidationError('Usá solo una identidad de receptor: --cuit, --cuil, --dni, --consumidor-final o --cfinal.');
     }
     return candidates[0] ?? {};
 }
@@ -45,8 +45,7 @@ export function resolveConceptShortcut(commandOptions) {
         commandOptions.csp ? 'productos-servicios' : null,
     ].filter(Boolean);
     if (shortcutConcepts.length > 1) {
-        throw new InputValidationError('Use solo un flag de concepto entre --cs, --cp o --csp.');
+        throw new InputValidationError('Usá solo un flag de concepto entre --cs, --cp o --csp.');
     }
     return shortcutConcepts[0];
 }
-//# sourceMappingURL=billing.command.shortcuts.js.map

package/dist/cli/commands/completion.command.js

@@ -0,0 +1,140 @@
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { billingIvaConditionSchema, IVA_RATE_ALIASES } from '../../modules/billing/billing.schemas.js';
+import { VOUCHER_LETTERS, VOUCHER_SHORTCUTS } from '../../modules/billing/voucher-kind-map.js';
+import { completeWords } from '../../modules/completion/completion.js';
+import { formatCompletionResultAsText, formatCompletionStateAsJson, formatCompletionStateAsText, } from '../../modules/completion/completion.presenter.js';
+import { currentCompletionEnvironment, detectShell, getCompletionState, installCompletion, uninstallCompletion, } from '../../modules/completion/installer.js';
+import { buildCompletionScript, COMPLETE_COMMAND, COMPLETION_SHELLS, } from '../../modules/completion/shell-scripts.js';
+import { configPublicKeySchema } from '../../modules/config/config.schemas.js';
+import { ConfigService } from '../../modules/config/config.service.js';
+import { EXPORT_VOUCHER_KIND } from '../../modules/export/export.types.js';
+import { CONFIG_FIELDS } from '../../modules/interactive/config-fields.js';
+import { PARAMETER_TABLE_NAMES } from '../../modules/parameters/parameters.js';
+import { writeTerminalJson, writeTerminalOutput } from '../../ui/index.js';
+import { registerJsonOption, resolveOutputJson } from '../global-options.js';
+import { configureSpanishHelp, createCompletionHelp } from '../help.js';
+/** No se ofrecen: herramientas internas. */
+const INTERNAL_COMMANDS = new Set([COMPLETE_COMMAND, 'storybook']);
+const IVA_RATES = [...new Set([...Object.values(IVA_RATE_ALIASES), '5', '2.5', ...Object.keys(IVA_RATE_ALIASES)])];
+/** Valores que aceptan las opciones, por flag largo. */
+const OPTION_VALUES = {
+    '--ac': VOUCHER_SHORTCUTS,
+    '--alicuota': IVA_RATES,
+    '--concepto': ['productos', 'servicios', 'productos-servicios'],
+    '--ir': billingIvaConditionSchema.options,
+    '--iva-receptor': billingIvaConditionSchema.options,
+    '--mda': ['ARS', 'USD'],
+    '--moneda': ['ARS', 'USD'],
+    '--transferencia': ['sca', 'adc'],
+};
+/** `config establecer <clave> <valor>`: el valor depende de la clave. */
+const configValues = ([key]) => CONFIG_FIELDS.find((field) => field.key === key)?.choices ?? [];
+/** Valores de los argumentos posicionales, por nombre del argumento. */
+const ARGUMENT_VALUES = {
+    clave: configPublicKeySchema.options,
+    letra: VOUCHER_LETTERS,
+    moneda: ['USD', 'DOL'],
+    shell: COMPLETION_SHELLS,
+    tabla: [...PARAMETER_TABLE_NAMES, 'cotizacion'],
+    tipo: VOUCHER_SHORTCUTS,
+    valor: configValues,
+};
+/** La familia `factura` tambien acepta la letra E (exportacion). */
+function argumentValues(command, name) {
+    return name === 'letra' && command.name() === EXPORT_VOUCHER_KIND.family
+        ? [...VOUCHER_LETTERS, EXPORT_VOUCHER_KIND.letter]
+        : ARGUMENT_VALUES[name];
+}
+/** El arbol de commander como lo necesita el autocompletado. */
+export function describeCompletionTree(command) {
+    return {
+        argumentValues: command.registeredArguments.map((argument) => argumentValues(command, argument.name())),
+        name: command.name(),
+        options: command.options.map((option) => ({
+            flags: [option.long, option.short].filter((flag) => Boolean(flag)),
+            hidden: option.hidden,
+            takesValue: option.required || option.optional,
+            values: option.long ? OPTION_VALUES[option.long] : undefined,
+        })),
+        subcommands: command.commands
+            .filter((subcommand) => !INTERNAL_COMMANDS.has(subcommand.name()))
+            .map(describeCompletionTree),
+    };
+}
+function parseShell(value) {
+    if (!COMPLETION_SHELLS.includes(value)) {
+        throw new InputValidationError(`El shell "${value}" no es válido. Usá ${COMPLETION_SHELLS.join(', ')}.`);
+    }
+    return value;
+}
+/** El shell pedido o, si no se paso, el de `$SHELL`. */
+export function resolveShell(value, environment) {
+    if (value) {
+        return parseShell(value);
+    }
+    const detected = detectShell(environment.shell);
+    if (!detected) {
+        throw new InputValidationError(`No se pudo saber qué shell usás${environment.shell ? ` (${environment.shell})` : ''}. Indicalo: bash, zsh o fish.`);
+    }
+    return detected;
+}
+function isJson(command) {
+    const service = new ConfigService();
+    try {
+        return resolveOutputJson(command, service.getConfig());
+    }
+    finally {
+        service.close();
+    }
+}
+export function registerCompletionCommands(program) {
+    const environment = currentCompletionEnvironment();
+    const command = registerJsonOption(program
+        .command('completado')
+        .description('autocompletado con Tab para bash, zsh o fish: instalarlo, desinstalarlo o ver el script')
+        .argument('[shell]', `${COMPLETION_SHELLS.join(', ')}: imprime el script; sin shell, muestra si está instalado`)).action((shell, _options, self) => {
+        if (shell) {
+            process.stdout.write(buildCompletionScript(parseShell(shell)));
+            return;
+        }
+        const state = getCompletionState(resolveShell(undefined, environment), environment);
+        if (isJson(self)) {
+            writeTerminalJson(formatCompletionStateAsJson(state));
+        }
+        else {
+            writeTerminalOutput(formatCompletionStateAsText(state, environment.home));
+        }
+    });
+    configureSpanishHelp(command);
+    command.addHelpText('after', createCompletionHelp());
+    // Pedir el comando ya es la confirmacion, como en `pdf instalar`: no se vuelve a preguntar.
+    for (const [name, description, run] of [
+        ['instalar', 'agregar el autocompletado al archivo de inicio del shell', installCompletion],
+        ['desinstalar', 'sacar el autocompletado que agrego arcli', uninstallCompletion],
+    ]) {
+        const subcommand = registerJsonOption(command
+            .command(name)
+            .description(description)
+            .argument('[shell]', `${COMPLETION_SHELLS.join(', ')}; por defecto el de $SHELL`)).action((shell, _options, self) => {
+            const result = run(resolveShell(shell, environment), environment);
+            if (isJson(self)) {
+                writeTerminalJson(formatCompletionStateAsJson(result));
+            }
+            else {
+                writeTerminalOutput(formatCompletionResultAsText(result, environment.home));
+            }
+        });
+        configureSpanishHelp(subcommand);
+    }
+    // Lo llama el script del shell en cada Tab: `arcli __completar -- <palabras escritas>`. Una por linea.
+    program
+        .command(COMPLETE_COMMAND, { hidden: true })
+        .argument('[palabras...]')
+        .allowUnknownOption()
+        .action((words = []) => {
+        const candidates = completeWords(describeCompletionTree(program), words);
+        if (candidates.length > 0) {
+            process.stdout.write(`${candidates.join('\n')}\n`);
+        }
+    });
+}

package/dist/cli/commands/config.command.js

@@ -1,8 +1,9 @@
 import { ConfigService } from '../../modules/config/config.service.js';
 import { buildConfigDoctorReport } from '../../modules/config/config-doctor.js';
 import { ArcaContextResolver } from '../../services/arca/arca-context.resolver.js';
-import { formatConfig, formatConfigAsText, formatConfigDoctor, formatConfigDoctorAsText, formatConfigPath, writeTerminalJson, writeTerminalOutput, } from '../../ui/index.js';
-import { configureSpanishHelp, createConfigHelp } from '../help.js';
+import { formatConfig, formatConfigAsText, formatConfigDoctor, formatConfigDoctorAsText, formatConfigPath, formatConfigPathAsJson, writeTerminalJson, writeTerminalOutput, } from '../../ui/index.js';
+import { registerJsonOption, resolveOutputJson } from '../global-options.js';
+import { configureSpanishHelp, createConfigHelp, createConfigSetHelp } from '../help.js';
 import { startSpinner } from '../spinner.js';
 function createConfigService() {
     const service = new ConfigService();
@@ -16,34 +17,33 @@ function printConfigResult(textValue, jsonValue, useJson = false) {
     }
     writeTerminalOutput(textValue);
 }
-export function buildRuntimeCheck(options) {
-    try {
-        return {
-            validation: new ArcaContextResolver({
-                options: {
-                    produccion: options.produccion,
-                    testing: options.testing,
-                },
-            }).validate(),
-        };
-    }
-    catch (error) {
-        return {
-            error: error instanceof Error ? error.message : 'No se pudo completar la revision activa.',
-        };
-    }
+const ENVIRONMENTS = ['testing', 'produccion'];
+/** Valida el entorno por defecto y cualquier otro que tenga cert o key cargados: `revisar` cubre los dos. */
+export function buildRuntimeChecks(config) {
+    return ENVIRONMENTS.filter((environment) => environment === config.entornoPorDefecto || Boolean(config.cert[environment] || config.key[environment])).map((environment) => {
+        try {
+            new ArcaContextResolver({ options: { [environment]: true } }).validate();
+            return { environment };
+        }
+        catch (error) {
+            return {
+                environment,
+                error: error instanceof Error ? error.message : 'No se pudo completar la validación.',
+            };
+        }
+    });
 }
 export function registerConfigCommand(program) {
     const configCommand = program
         .command('config')
-        .description('guardar defaults, credenciales y revisar si el CLI esta listo para emitir');
+        .description('guardar defaults, credenciales y revisar si el CLI está listo para emitir');
     configureSpanishHelp(configCommand);
-    configCommand.option('--json', 'imprimir salida JSON').action((options) => {
+    registerJsonOption(configCommand).action((_options, command) => {
         const service = createConfigService();
         try {
             const config = service.getConfig();
             const paths = service.resolvePaths(config);
-            printConfigResult(formatConfigAsText(config, paths), formatConfig(config, paths), options.json);
+            printConfigResult(formatConfigAsText(config, paths), formatConfig(config, paths), resolveOutputJson(command, config));
         }
         finally {
             service.close();
@@ -52,17 +52,17 @@ export function registerConfigCommand(program) {
     configCommand.addHelpText('after', createConfigHelp());
     const revisarCommand = configCommand
         .command('revisar')
-        .description('revisar configuracion, defaults, credenciales y validacion activa')
-        .option('--json', 'imprimir salida JSON')
-        .option('--testing', 'revisar para testing')
-        .option('--produccion', 'revisar para produccion')
-        .action((options) => {
+        .description('revisar configuración, defaults, credenciales y validación de cada entorno')
+        .action((_options, command) => {
         const service = createConfigService();
-        const spinner = options.json ? null : startSpinner('Generando revision...');
+        let spinner = null;
         try {
-            const report = buildConfigDoctorReport(service.getConfig(), buildRuntimeCheck(options));
+            const config = service.getConfig();
+            const useJson = resolveOutputJson(command, config);
+            spinner = useJson ? null : startSpinner('Generando revisión...');
+            const report = buildConfigDoctorReport(config, buildRuntimeChecks(config));
             spinner?.stop();
-            printConfigResult(formatConfigDoctorAsText(report), formatConfigDoctor(report), options.json);
+            printConfigResult(formatConfigDoctorAsText(report), formatConfigDoctor(report), useJson);
         }
         catch (error) {
             spinner?.stop();
@@ -72,14 +72,13 @@ export function registerConfigCommand(program) {
             service.close();
         }
     });
+    registerJsonOption(revisarCommand);
     configureSpanishHelp(revisarCommand);
-    const rutaCommand = configCommand
-        .command('ruta')
-        .description('mostrar la ruta del archivo de configuracion')
-        .action(() => {
+    const rutaCommand = registerJsonOption(configCommand.command('ruta').description('mostrar la ruta del archivo de configuración')).action((_options, command) => {
         const service = createConfigService();
         try {
-            writeTerminalOutput(formatConfigPath(service.getPath()));
+            const path = service.getPath();
+            printConfigResult(formatConfigPath(path), formatConfigPathAsJson(path), resolveOutputJson(command, service.getConfig()));
         }
         finally {
             service.close();
@@ -88,40 +87,40 @@ export function registerConfigCommand(program) {
     configureSpanishHelp(rutaCommand);
     const establecerCommand = configCommand
         .command('establecer')
-        .description('guardar un valor de configuracion')
-        .option('--json', 'imprimir salida JSON')
-        .argument('<clave>', 'clave publica de configuracion')
+        .description('guardar un valor de configuración')
+        .argument('<clave>', 'clave publica de configuración')
         .argument('<valor>', 'valor a guardar')
-        .action((key, value, options) => {
+        .addHelpText('after', createConfigSetHelp())
+        .action((key, value, _options, command) => {
         // Sin ensureInitialized: si la config quedo invalida, establecer o eliminar la clave es la forma de arreglarla.
         const service = new ConfigService();
         try {
             const config = service.setValue(key, value);
             const paths = service.resolvePaths(config);
-            printConfigResult(formatConfigAsText(config, paths), formatConfig(config, paths), options.json);
+            printConfigResult(formatConfigAsText(config, paths), formatConfig(config, paths), resolveOutputJson(command, config));
         }
         finally {
             service.close();
         }
     });
+    registerJsonOption(establecerCommand);
     configureSpanishHelp(establecerCommand);
     const eliminarCommand = configCommand
         .command('eliminar')
-        .description('eliminar un valor de configuracion')
-        .option('--json', 'imprimir salida JSON')
-        .argument('<clave>', 'clave publica de configuracion')
-        .action((key, options) => {
+        .description('eliminar un valor de configuración')
+        .argument('<clave>', 'clave publica de configuración')
+        .action((key, _options, command) => {
         // Sin ensureInitialized: si la config quedo invalida, establecer o eliminar la clave es la forma de arreglarla.
         const service = new ConfigService();
         try {
             const config = service.unsetValue(key);
             const paths = service.resolvePaths(config);
-            printConfigResult(formatConfigAsText(config, paths), formatConfig(config, paths), options.json);
+            printConfigResult(formatConfigAsText(config, paths), formatConfig(config, paths), resolveOutputJson(command, config));
         }
         finally {
             service.close();
         }
     });
+    registerJsonOption(eliminarCommand);
     configureSpanishHelp(eliminarCommand);
 }
-//# sourceMappingURL=config.command.js.map

package/dist/cli/commands/cuit-argument.js

@@ -0,0 +1,10 @@
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { parseCuit } from '../../lib/identity/cuit.js';
+/** CUIT de un argumento posicional, con o sin guiones. */
+export function parseCuitArgument(value) {
+    const result = parseCuit(value);
+    if (!result.ok) {
+        throw new InputValidationError(`El CUIT "${value}" no es válido: ${result.reason}.`);
+    }
+    return Number(result.value);
+}

package/dist/cli/commands/examples.command.js

@@ -11,4 +11,3 @@ export function registerExamplesCommand(program) {
         .addHelpText('after', createExamplesHelp());
     configureSpanishHelp(command);
 }
-//# sourceMappingURL=examples.command.js.map

package/dist/cli/commands/export-shortcut.command.js

@@ -0,0 +1,19 @@
+import { EXPORT_VOUCHER_KIND } from '../../modules/export/export.types.js';
+import { registerGlobalOptions } from '../global-options.js';
+import { configureSpanishHelp, createExportShortcutHelp } from '../help.js';
+import { executeExportCommand } from './export.command.js';
+import { registerExportOptions } from './export.command.options.js';
+/** `arcli fe`: el atajo de la factura E, como `fa`, `fb` y `fc`. Es lo mismo que `arcli factura e`. */
+export function registerExportShortcutCommand(program) {
+    // Oculto en la lista de comandos: la ayuda principal lo muestra en la tabla de atajos.
+    const command = program
+        .command(EXPORT_VOUCHER_KIND.shortcut, { hidden: true })
+        .description(`${EXPORT_VOUCHER_KIND.displayName} por shortcut (WSFEX), con ayuda guiada para previsualizar o emitir`);
+    configureSpanishHelp(command);
+    registerGlobalOptions(command);
+    registerExportOptions(command);
+    command.action(async () => {
+        await executeExportCommand(command);
+    });
+    command.addHelpText('after', createExportShortcutHelp());
+}

package/dist/cli/commands/export.command.js

@@ -0,0 +1,106 @@
+import { ExportService } from '../../modules/export/export.service.js';
+import { EXPORT_VOUCHER_KIND } from '../../modules/export/export.types.js';
+import { ArcaClientFactory } from '../../services/arca/arca-client.factory.js';
+import { ArcaExportGateway } from '../../services/arca/arca-export.gateway.js';
+import { formatExportResultAsJson, formatExportResultAsText, formatPdfOutcomeAsText, writeTerminalJson, writeTerminalOutput, } from '../../ui/index.js';
+import { certificateWarnings, resolveArcaRuntime } from '../arca-runtime.js';
+import { getGlobalOptions } from '../global-options.js';
+import { chooseOne } from '../interactive/prompts.js';
+import { startSpinner } from '../spinner.js';
+import { REJECTED_EXIT_CODE } from './billing.command.shared.js';
+import { parseExportCommandPlan } from './export.command.parser.js';
+import { attachExportPdf } from './export.command.pdf.js';
+const ITEMS_DESCRIPTION_WARNING = '--descripcion se usa solo cuando no hay --item: el detalle del comprobante sale de los items.';
+function writeExportResult(result, options) {
+    if (options.outputJson) {
+        writeTerminalJson(formatExportResultAsJson(result, { raw: options.raw }));
+        return;
+    }
+    writeTerminalOutput(formatExportResultAsText(result, {
+        environment: options.environment,
+        previewShown: options.previewShown,
+        raw: options.raw,
+    }));
+}
+function resolveWarnings(certificateWarningsList, input) {
+    const ignored = input.items && input.items.length > 0 && input.description?.trim() ? [ITEMS_DESCRIPTION_WARNING] : [];
+    return [...certificateWarningsList, ...ignored];
+}
+/** Esc cuenta como no, igual que en A, B y C. */
+async function promptForEmission() {
+    return chooseOne(`¿Querés emitir ${EXPORT_VOUCHER_KIND.displayName} ahora?`, [
+        { name: 'Sí, emitir ahora', value: true },
+        { name: 'No, dejar sin emitir', value: false },
+    ], true, { escapeLabel: 'no emitir', escapeValue: false });
+}
+/**
+ * Un comprobante por ejecucion: resuelve el payload contra WSFEX, muestra la vista previa si corresponde,
+ * emite y, si hay CAE, genera el PDF.
+ */
+export async function executeExportCommand(command, options = {}) {
+    const globalOptions = getGlobalOptions(command);
+    let spinner = null;
+    try {
+        const runtime = resolveArcaRuntime(globalOptions);
+        const plan = parseExportCommandPlan(command, { defaultEmit: runtime.config.output.emitirPorDefecto });
+        const useRaw = typeof globalOptions.bruto === 'boolean' ? globalOptions.bruto : runtime.outputRaw;
+        const interactive = !runtime.outputJson && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        const service = new ExportService();
+        const gateway = new ArcaExportGateway(new ArcaClientFactory().createForExport(runtime));
+        spinner = runtime.outputJson ? null : startSpinner('Consultando WSFEX...');
+        const resolved = await service.resolve(plan.input, gateway, runtime);
+        // Los avisos de la resolucion (por ejemplo, la cotizacion de un dia anterior) van con los del certificado.
+        const warnings = [
+            ...resolveWarnings(certificateWarnings(runtime), plan.input),
+            ...(options.extraWarnings ?? []),
+            ...(resolved.warnings ?? []),
+        ];
+        spinner?.stop();
+        spinner = null;
+        let result = service.preview(resolved, runtime, warnings);
+        let previewShown = false;
+        if (!plan.input.emit) {
+            // Sin flags de emision y con terminal: se muestra la vista previa y se pregunta. Con --json o sin
+            // terminal nadie puede responder, asi que queda en vista previa.
+            if (plan.modeSource !== 'default' || !interactive) {
+                writeExportResult(result, {
+                    environment: runtime.environment,
+                    outputJson: runtime.outputJson,
+                    previewShown: false,
+                    raw: useRaw,
+                });
+                return;
+            }
+            writeTerminalOutput(formatExportResultAsText(result, { environment: runtime.environment, raw: useRaw }));
+            if (!(await promptForEmission())) {
+                return;
+            }
+            previewShown = true;
+        }
+        spinner = runtime.outputJson ? null : startSpinner('Emitiendo comprobante...');
+        result = await service.execute({ gateway, resolved, runtime, warnings });
+        spinner?.stop();
+        spinner = null;
+        result = await attachExportPdf(result, {
+            config: runtime.config,
+            input: plan.input,
+            interactive,
+        });
+        writeExportResult(result, {
+            environment: runtime.environment,
+            outputJson: runtime.outputJson,
+            previewShown,
+            raw: useRaw,
+        });
+        if (result.response.status === 'rechazado') {
+            process.exitCode = REJECTED_EXIT_CODE;
+        }
+        if (result.pdf && !runtime.outputJson) {
+            writeTerminalOutput(formatPdfOutcomeAsText(result.pdf));
+        }
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}

package/dist/cli/commands/export.command.options.js

@@ -0,0 +1,140 @@
+import { Option } from 'commander';
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { EXCHANGE_RATE_DECIMALS } from '../../lib/numbers/argentine-amount.js';
+import { parseStrictInteger } from '../../lib/numbers/strict-integer.js';
+import { parseExportItemArgument } from '../../modules/export/export.items.js';
+import { amountOption, integerOption } from '../option-parsers.js';
+function exportTypeOption(value) {
+    const parsed = parseStrictInteger(value);
+    if (parsed !== 1 && parsed !== 2 && parsed !== 4) {
+        throw new InputValidationError(`--tipo-expo "${value}" no es válido: usá 1 (bienes), 2 (servicios) o 4 (otros).`);
+    }
+    return parsed;
+}
+function repeatable(parse) {
+    return (value, previous) => [...(Array.isArray(previous) ? previous : []), parse(value)];
+}
+const EXPORT_OPTIONS = [
+    {
+        description: 'importe total del comprobante, por ejemplo 15000 o 1.500,50',
+        flags: '-m, --monto <numero>',
+        parser: amountOption('--monto'),
+    },
+    { description: 'nombre o razón social del cliente del exterior', flags: '--cliente <texto>' },
+    { description: 'domicilio del cliente en el exterior', flags: '--domicilio-cliente <texto>' },
+    {
+        description: 'país de destino por código o nombre, por ejemplo 203 o Brasil',
+        flags: '--pais-destino <codigo|nombre>',
+    },
+    { description: 'ID impositivo del cliente en su país', flags: '--id-impositivo <texto>' },
+    {
+        description: 'CUIT del país del cliente; sin este flag se resuelve desde el país de destino',
+        flags: '--cuit-pais <numero>',
+        parser: integerOption('--cuit-pais'),
+    },
+    {
+        description: 'tipo de exportación: 1 bienes, 2 servicios (por defecto), 4 otros',
+        flags: '--tipo-expo <1|2|4>',
+        parser: exportTypeOption,
+    },
+    {
+        description: 'código de la tabla de actividades de WSFEX, por ejemplo 620100; sin flag, exportacion.actividad de la config',
+        flags: '--actividad <codigo>',
+        parser: integerOption('--actividad'),
+    },
+    { description: 'código de incoterm, por ejemplo FOB', flags: '--incoterm <codigo>' },
+    { description: 'descripción del incoterm; por defecto la de la tabla de ARCA', flags: '--incoterms-desc <texto>' },
+    {
+        description: 'código de idioma del comprobante: 1 español (por defecto), 2 inglés, 3 portugués',
+        flags: '--idioma <codigo>',
+        parser: integerOption('--idioma'),
+    },
+    { description: 'forma de pago; por defecto "Transferencia Internacional"', flags: '--forma-pago <texto>' },
+    {
+        description: 'permiso de embarque ya existente; repetible. Requiere --permiso-existente y --tipo-expo 1',
+        flags: '--permiso <id>',
+        parser: repeatable((value) => value),
+    },
+    {
+        description: 'el permiso de embarque informado ya existe en ARCA',
+        flags: '--permiso-existente',
+    },
+    {
+        description: 'item del comprobante: "codigo|descripcion|cantidad|precio|unidad". Repetible; la suma tiene que dar --monto',
+        flags: '--item <partes>',
+        parser: repeatable((value) => parseExportItemArgument(value)),
+    },
+    {
+        description: 'número del comprobante; por defecto el siguiente de ARCA',
+        flags: '--numero <numero>',
+        parser: integerOption('--numero'),
+    },
+    {
+        description: 'ID de la solicitud; por defecto el siguiente de ARCA',
+        flags: '--id-solicitud <numero>',
+        parser: integerOption('--id-solicitud'),
+    },
+    {
+        description: 'punto de venta (alias: --pv)',
+        flags: '--punto-venta <numero>',
+        parser: integerOption('--punto-venta'),
+    },
+    { description: 'alias de --punto-venta', flags: '--pv <numero>', hidden: true, parser: integerOption('--pv') },
+    { description: 'fecha del comprobante; acepta D, D/M, D/M/YY o D/M/YYYY con - o /', flags: '-f, --fecha <fecha>' },
+    { description: 'fecha de pago; por defecto la del comprobante', flags: '--fecha-pago <fecha>' },
+    { description: 'código de moneda: USD o DOL (por defecto), ARS o PES (alias: --mda)', flags: '--moneda <codigo>' },
+    { description: 'alias de --moneda', flags: '--mda <codigo>', hidden: true },
+    {
+        description: 'cotización de la moneda; sin este flag se usa la de aduana que publica ARCA (alias: --cm)',
+        flags: '--cotizacion-moneda <numero>',
+        parser: amountOption('--cotizacion-moneda', EXCHANGE_RATE_DECIMALS),
+    },
+    {
+        description: 'alias de --cotizacion-moneda',
+        flags: '--cm <numero>',
+        hidden: true,
+        parser: amountOption('--cm', EXCHANGE_RATE_DECIMALS),
+    },
+    { description: 'el pago se cancela en la misma moneda extranjera', flags: '--misma-moneda' },
+    { description: 'observaciones del comprobante', flags: '--observaciones <texto>' },
+    { description: 'observaciones comerciales del comprobante', flags: '--obs-comerciales <texto>' },
+    {
+        description: 'descripción del comprobante cuando no se informan items; también va al PDF',
+        flags: '--descripcion <texto>',
+    },
+    { description: 'cargar los datos desde un archivo JSON', flags: '--cargar <ruta>' },
+    {
+        description: 'generar el PDF del comprobante emitido, aunque la config diga otra cosa (alias: --pdf)',
+        flags: '--exportar-pdf',
+    },
+    { description: 'alias de --exportar-pdf', flags: '--pdf', hidden: true },
+    { description: 'no generar el PDF, aunque la config diga otra cosa', flags: '--sin-pdf' },
+    { description: 'mostrar el payload antes de emitir en ARCA', flags: '--previsualizar' },
+    { description: 'emitir realmente en ARCA', flags: '--emitir' },
+];
+/** Los flags largos que aplican a la factura E, incluidos los que comparte con A, B y C (`--monto`, `--fecha`...). */
+export const EXPORT_OPTION_FLAGS = new Set(EXPORT_OPTIONS.map((definition) => new Option(definition.flags).long).filter((flag) => Boolean(flag)));
+/**
+ * Registra las opciones de la factura E. `hidden` las registra sin mostrarlas: `arcli factura <letra>` las acepta
+ * para la letra E. Las que el comando ya tiene (`--monto`, `--fecha`...) se reusan. Devuelve las que agrego.
+ */
+export function registerExportOptions(command, options = {}) {
+    const existing = new Set(command.options.flatMap((option) => [option.short, option.long]).filter((flag) => Boolean(flag)));
+    const added = [];
+    for (const definition of EXPORT_OPTIONS) {
+        const option = new Option(definition.flags, definition.description);
+        const flags = [option.short, option.long].filter((flag) => Boolean(flag));
+        if (flags.some((flag) => existing.has(flag))) {
+            continue;
+        }
+        if (definition.parser) {
+            option.argParser(definition.parser);
+        }
+        if (options.hidden || definition.hidden) {
+            option.hideHelp();
+        }
+        command.addOption(option);
+        added.push(option);
+    }
+    return added;
+}