facturas 0.9.0 → 0.11.0

package/dist/client-BZxeScuK.d.ts

@@ -0,0 +1,521 @@
+import { h as ArcaEnvironment, A as ArcaClientOptions } from './types-r2nf55gh.js';
+import { PadronService } from './padron.js';
+import { s as WsfeVoucherInput, S as SupportedVatRate, r as WsfeVoucherInfo, i as WsfeDateInput, o as WsfeService } from './decimal-B0HtrMFY.js';
+import { VoucherClass, ReceiverCondition, IssuerCondition } from './constants.js';
+import { A as ArcaAuthorizationOutcome, i as ArcaFiscalIssue, q as ArcaSafeErrorMetadata } from './fiscal-evidence-B1Qe6XMg.js';
+import { WsmtxcaService } from './wsmtxca.js';
+
+/** Detailed item evidence. Amounts are cents; unitPrice is a decimal major-unit string. */
+type VoucherItemDetail = {
+    description: string;
+    quantity: number;
+    unit: number;
+    unitPrice: string;
+    discount?: number;
+    vatCondition: number;
+    vatAmount?: number;
+    amount: number;
+    code?: string;
+    matrixCode?: string;
+    matrixUnits?: number;
+};
+type WsmtxcaIssueRequest = ReturnType<typeof wsmtxcaRequest>;
+type FiscalHeader = WsfeVoucherInput & {
+    details?: readonly VoucherItemDetail[];
+};
+declare function wsmtxcaRequest(data: FiscalHeader, number?: number): {
+    comprobanteCAERequest: {
+        arrayComprobantesAsociados: {
+            comprobanteAsociado: {
+                codigoTipoComprobante: number;
+                numeroPuntoVenta: number;
+                numeroComprobante: number;
+                cuit: string | undefined;
+                fechaEmision: string | undefined;
+            }[];
+        } | undefined;
+        periodoComprobantesAsociados: {
+            fechaDesde: string | undefined;
+            fechaHasta: string | undefined;
+        } | undefined;
+        arrayCompradores: {
+            comprador: {
+                codigoTipoDocumento: number;
+                numeroDocumento: number;
+                porcentaje: number;
+            }[];
+        } | undefined;
+        arrayOtrosTributos: {
+            otroTributo: {
+                codigo: number;
+                descripcion: string | undefined;
+                baseImponible: number;
+                importe: number;
+            }[];
+        } | undefined;
+        arrayItems: {
+            item: {
+                importeItem: number;
+                importeIVA?: number | undefined;
+                unidadesMtx: number | undefined;
+                codigoMtx: string | undefined;
+                codigo: string | undefined;
+                descripcion: string;
+                cantidad: number;
+                codigoUnidadMedida: number;
+                precioUnitario: string;
+                importeBonificacion: number;
+                codigoCondicionIVA: number;
+            }[];
+        };
+        arraySubtotalesIVA: {
+            subtotalIVA: {
+                codigo: number;
+                importe: number;
+            }[];
+        } | undefined;
+        arrayDatosAdicionales: {
+            datoAdicional: ({
+                t: number;
+                c1: string;
+            } | {
+                t: number;
+                c1: string | undefined;
+                c2: string | undefined;
+            })[];
+        } | undefined;
+        arrayActividades: {
+            actividad: {
+                codigo: number;
+            }[];
+        } | undefined;
+        cancelaEnMismaMonedaExtranjera?: "S" | "N" | undefined;
+        fechaEmision: string | undefined;
+        codigoTipoDocumento: number;
+        numeroDocumento: number;
+        condicionIVAReceptor: number;
+        importeGravado: number;
+        importeNoGravado: number;
+        importeExento: number;
+        importeSubtotal: number;
+        importeOtrosTributos: number;
+        importeTotal: number;
+        codigoMoneda: string;
+        cotizacionMoneda: string | number | undefined;
+        codigoConcepto: number;
+        fechaServicioDesde: string | undefined;
+        fechaServicioHasta: string | undefined;
+        fechaVencimientoPago: string | undefined;
+        numeroComprobante?: number | undefined;
+        codigoTipoComprobante: number;
+        numeroPuntoVenta: number;
+    };
+};
+
+type VatRate = SupportedVatRate | "exempt" | "untaxed";
+type VatItem = {
+    net: number;
+    gross?: never;
+    amount?: never;
+    vat: VatRate;
+} | {
+    gross: number;
+    net?: never;
+    amount?: never;
+    vat: VatRate;
+};
+type AmountItem = {
+    amount: number;
+    vat?: never;
+    net?: never;
+    gross?: never;
+};
+type IssueAmounts = {
+    computedTotal: number;
+    sentTotal: number;
+    vatAdjustment: number;
+};
+
+type VoucherCoordinates = {
+    salesPoint: number;
+    voucherType: number;
+    number: number;
+};
+/** Raw-free consultation evidence. Missing provider fields remain absent. */
+type VoucherSummary = {
+    number: number;
+    salesPoint?: number;
+    voucherType?: number;
+    date?: string;
+    concept?: number;
+    documentType?: number;
+    documentNumber?: string;
+    receiverVatConditionId?: number;
+    currencyId?: string;
+    exchangeRate?: number;
+    totalAmount?: number;
+    netAmount?: number;
+    vatAmount?: number;
+    exemptAmount?: number;
+    nonTaxableAmount?: number;
+    taxAmount?: number;
+    vatRates?: {
+        id: number;
+        baseAmount: number;
+        amount: number;
+    }[];
+    serviceStartDate?: string;
+    serviceEndDate?: string;
+    paymentDueDate?: string;
+    result?: string;
+    cae?: string;
+    caeExpiry?: string;
+};
+type WsfeIdentityMatch = {
+    matches: true;
+} | {
+    matches: false;
+    evidence: "conflict" | "incomplete";
+    reason: string;
+};
+/**
+ * Compares the invoice subset supported by issue(): header identity, amounts,
+ * VAT, tributes, associations, optional fields, buyers, activities and the
+ * foreign-currency payment flag. This proves consistency, not authorship.
+ * Configure a store and pass idempotencyKey for retries. Exact-API extensions
+ * outside that subset stay incomplete; a missing field is never proof.
+ */
+declare function matchWsfeVoucherIdentity(sent: WsfeVoucherInput, number: number, found: WsfeVoucherInfo): WsfeIdentityMatch;
+
+type IssueOptions = {
+    service?: "wsfe" | "wsmtxca";
+    /** An externally reserved number. Never reads the next number when supplied. */
+    number?: number;
+    idempotencyKey?: string;
+    representedTaxId?: number | string;
+    forceRefresh?: boolean;
+    include?: {
+        raw?: boolean;
+        exactInput?: boolean;
+    };
+};
+type IssuedVoucher = VoucherCoordinates & {
+    voucherClass: VoucherClass;
+    date: string;
+    cae: string;
+    caeExpiry: string;
+    amounts: IssueAmounts;
+};
+/** The provider a call targets. It is chosen explicitly, never switched. */
+type IssuanceService = "wsfe" | "wsmtxca";
+type ServiceFor<O extends IssueOptions> = "service" extends keyof O ? "wsmtxca" extends O["service"] ? O extends {
+    service: "wsmtxca";
+} ? "wsmtxca" : IssuanceService : "wsfe" : "wsfe";
+type ExactIssueInput<S extends IssuanceService = "wsfe"> = S extends "wsmtxca" ? WsmtxcaIssueRequest : WsfeVoucherInput;
+/**
+ * What issue() would send, derived with zero I/O. The voucher number is absent
+ * because it is only known when the number is reserved at issuance.
+ */
+type IssuePreview<S extends IssuanceService = "wsfe"> = {
+    voucherClass: VoucherClass;
+    voucherType: number;
+    amounts: IssueAmounts;
+    request: ExactIssueInput<S>;
+    service?: S;
+};
+type WithRaw<T, O extends IssueOptions> = T & (true extends NonNullable<O["include"]>["raw"] ? {
+    raw?: Record<string, unknown>;
+} : unknown);
+type WithSent<O extends IssueOptions> = O extends {
+    include: {
+        exactInput: true;
+    };
+} ? {
+    sent: ExactIssueInput<ServiceFor<O>>;
+} : true extends NonNullable<O["include"]>["exactInput"] ? {
+    sent?: ExactIssueInput<ServiceFor<O>>;
+} : unknown;
+type Evidence<K extends ArcaAuthorizationOutcome["kind"], O extends IssueOptions> = WithRaw<Omit<Extract<ArcaAuthorizationOutcome<ServiceFor<O>>, {
+    kind: K;
+}>, "raw">, O>;
+/** Fiscal outcomes are returned. Keyed replays authorize only after not_found. */
+type IssueOutcome<O extends IssueOptions = {
+    include?: never;
+}> = ({
+    kind: "authorized";
+    recoveredByMatch: false;
+    voucher: IssuedVoucher;
+    authorization: Evidence<"authorized", O>;
+} & WithSent<O>) | ({
+    kind: "authorized";
+    recoveredByMatch: true;
+    voucher: IssuedVoucher;
+    attempt: Evidence<"indeterminate", O>;
+    lookup: WithRaw<VoucherSummary, O>;
+} & WithSent<O>) | {
+    kind: "rejected";
+    attempted: VoucherCoordinates;
+    issues: ArcaFiscalIssue[];
+    authorization: Evidence<"rejected", O>;
+} | {
+    kind: "indeterminate";
+    attempted: VoucherCoordinates;
+    attempt: Evidence<"indeterminate", O>;
+    lookup: WithRaw<{
+        kind: "not_found";
+    }, O> | WithRaw<{
+        kind: "incomplete";
+        reason: string;
+    }, O> | {
+        kind: "failed";
+        error: ArcaSafeErrorMetadata;
+    };
+} | {
+    kind: "conflict";
+    attempted: VoucherCoordinates;
+    attempt: Evidence<"indeterminate", O>;
+    found: WithRaw<VoucherSummary, O>;
+    reason: string;
+};
+
+/** Monetary values in the high-level API are integer minor units. */
+type Tribute = {
+    id: number;
+    description?: string;
+    base: number;
+    rate: number;
+    amount: number;
+};
+/** An already-reviewed fiscal breakdown; no recalculation of historical VAT. */
+type VoucherAmounts = {
+    net: number;
+    vat: number;
+    exempt?: number;
+    untaxed?: number;
+    vatRates?: readonly {
+        id: number;
+        base: number;
+        amount: number;
+    }[];
+};
+type InvoiceFamily = "ordinary" | "retention_legend" | "fce";
+type IssuanceFields = {
+    fce?: FceOptions;
+    taxes?: readonly Tribute[];
+    amounts?: VoucherAmounts;
+    concept?: "products" | "services" | "products_and_services";
+    dueDate?: WsfeDateInput;
+    paidInForeignCurrency?: boolean;
+    optionalFields?: WsfeVoucherInput["optionalFields"];
+    buyers?: WsfeVoucherInput["buyers"];
+    activities?: WsfeVoucherInput["activities"];
+};
+/** FCE business fields; the SDK encodes each provider's different option layout. */
+type FceOptions = {
+    cbu?: string;
+    alias?: string;
+    transfer?: "ADC" | "SCA";
+    annulment?: boolean;
+    reference?: string;
+};
+
+type Receiver = {
+    condition: number;
+    cuit?: string | number;
+    dni?: string | number;
+    document?: {
+        type: number;
+        number: string | number;
+    };
+} | {
+    condition: "consumidor_final";
+    cuit?: number | string;
+    dni?: number | string;
+} | {
+    condition: Exclude<ReceiverCondition, "consumidor_final">;
+    cuit: number | string;
+    dni?: never;
+};
+type IssueCommon = IssuanceFields & {
+    family?: InvoiceFamily;
+    details?: readonly VoucherItemDetail[];
+    salesPoint: number;
+    to: Receiver;
+    total?: number;
+    date?: WsfeDateInput;
+    currency?: "ARS" | "USD" | {
+        id: string;
+    };
+    exchangeRate?: string;
+    service?: {
+        from: WsfeDateInput;
+        to: WsfeDateInput;
+        dueDate: WsfeDateInput;
+    };
+};
+type IssueInput = IssueCommon & ({
+    issuer: "responsable_inscripto";
+    items: readonly VatItem[];
+    amounts?: never;
+} | {
+    issuer: "monotributo" | "exento" | "no_alcanzado";
+    items: readonly AmountItem[];
+    amounts?: never;
+} | {
+    issuer: IssuerCondition;
+    amounts: VoucherAmounts;
+    items?: never;
+});
+
+/**
+ * The credited lines and, at most, the note's own sales point and date.
+ * Class, receiver, currency, concept and service dates come from the original.
+ *
+ * The mode is explicit: `items` or a reviewed `amounts` breakdown credits the
+ * chosen lines, `all: true` credits the whole original. A forgotten field never
+ * credits the whole invoice. A full note mirrors the original's tributes; a
+ * partial note carries the `taxes` the caller chose, never a prorated share.
+ */
+type CreditNoteInput = Pick<IssuanceFields, "taxes" | "optionalFields" | "fce"> & {
+    details?: readonly VoucherItemDetail[];
+    /** The authorized invoice or debit note the note corrects. */
+    for: VoucherCoordinates;
+    salesPoint?: number;
+    date?: WsfeDateInput;
+} & ({
+    items: NonNullable<IssueInput["items"]>;
+    total?: number;
+    all?: never;
+    amounts?: never;
+} | {
+    amounts: VoucherAmounts;
+    items?: never;
+    total?: number;
+    all?: never;
+} | {
+    all: true;
+    items?: never;
+    total?: never;
+    amounts?: never;
+});
+
+type PeriodNoteInput = IssueInput & {
+    associatedPeriod: {
+        from: WsfeDateInput;
+        to: WsfeDateInput;
+    };
+    for?: never;
+};
+type DebitNoteInput = (CreditNoteInput & {
+    all?: never;
+}) | PeriodNoteInput;
+type RecoveryOptions = Pick<IssueOptions, "representedTaxId" | "forceRefresh" | "include">;
+type VouchersService = {
+    /** Consults a durable reservation. Never allocates or authorizes a voucher. */
+    recover<O extends RecoveryOptions = {
+        include?: never;
+    }>(idempotencyKey: string, options?: O): Promise<IssueOutcome<O & {
+        service?: IssuanceService;
+    }>>;
+    /**
+     * Issues a debit note against the same originals `issueCreditNote()` accepts,
+     * or against a period with `associatedPeriod`. It has no `all: true` mode:
+     * a debit note adds to the account, so its lines are always explicit.
+     */
+    issueDebitNote<O extends IssueOptions = {
+        include?: never;
+    }>(input: DebitNoteInput, options?: O): Promise<IssueOutcome<O>>;
+    /**
+     * Derives what issueCreditNote() would send. Unlike the zero-I/O preview(),
+     * it consults the original once: one read, no write and no number reserved.
+     * A period note carries its own business input and needs no lookup.
+     */
+    previewCreditNote<O extends PreviewOptions = {
+        service?: never;
+    }>(input: CreditNoteInput | PeriodNoteInput, options?: O): Promise<IssuePreview<ServiceFor<O>>>;
+    /** Same contract as previewCreditNote(), for issueDebitNote() input. */
+    previewDebitNote<O extends PreviewOptions = {
+        service?: never;
+    }>(input: DebitNoteInput, options?: O): Promise<IssuePreview<ServiceFor<O>>>;
+    /**
+     * Issues a credit note against an authorized invoice or debit note of the
+     * ordinary, retention-legend or FCE families, or against a period with
+     * `associatedPeriod`. The note credits the chosen `items` or reviewed
+     * `amounts`, or the whole original with `all: true`.
+     *
+     * For a linked note everything except the credited lines, the note's sales
+     * point and its date comes from the original: class, receiver, currency,
+     * concept and service dates. ARCA has no cancellation; every mode writes a
+     * real fiscal document.
+     */
+    issueCreditNote<O extends IssueOptions = {
+        include?: never;
+    }>(input: CreditNoteInput | PeriodNoteInput, options?: O): Promise<IssueOutcome<O>>;
+    /**
+     * Configure a store and pass idempotencyKey to recover retries after a crash.
+     *
+     * Without a key: one next-number read, one authorization and at most one lookup.
+     * Keyed replay consults the reserved number; only not_found permits a write.
+     * Local validation and next-number read failures throw before authorization.
+     */
+    issue<O extends IssueOptions = {
+        include?: never;
+    }>(input: IssueInput, options?: O): Promise<IssueOutcome<O>>;
+    /**
+     * Derives what issue() would send for the same input, with no I/O at all:
+     * no store, no WSAA, no SOAP and no next-number read.
+     *
+     * It throws every input error issue() throws before its first call, so a
+     * caller that previews and then issues sees no new local error.
+     */
+    preview<O extends Pick<PreviewOptions, "representedTaxId" | "service"> = {
+        service?: never;
+    }>(input: IssueInput, options?: O): IssuePreview<ServiceFor<O>>;
+};
+type PreviewOptions = {
+    representedTaxId?: number | string;
+    service?: "wsfe" | "wsmtxca";
+    forceRefresh?: boolean;
+};
+
+/** Immutable, credential-free operational view of an ARCA client configuration. */
+type ArcaClientConfigView = Readonly<{
+    taxId: string;
+    environment: ArcaEnvironment;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+}>;
+/** Fully wired ARCA client with access to all service modules. */
+type ArcaClient = {
+    readonly config: ArcaClientConfigView;
+    /** Issues an invoice from business input. Idempotent with a store and key. */
+    issue: VouchersService["issue"];
+    /** Derives what issue() would send for the same input, with no I/O. */
+    preview: VouchersService["preview"];
+    /** Issues a credit note against an authorized original or a period. */
+    issueCreditNote: VouchersService["issueCreditNote"];
+    /** Consults a durable reservation. Never allocates or authorizes a voucher. */
+    recover: VouchersService["recover"];
+    /** Issues a debit note against an authorized original or a period. */
+    issueDebitNote: VouchersService["issueDebitNote"];
+    /** Derives a credit note; reads the original but reserves no number. */
+    previewCreditNote: VouchersService["previewCreditNote"];
+    /** Derives a debit note; reads the original but reserves no number. */
+    previewDebitNote: VouchersService["previewDebitNote"];
+    wsfe: WsfeService;
+    wsmtxca: WsmtxcaService;
+    padron: PadronService;
+};
+/**
+ * Creates an ARCA client from the given configuration.
+ * Validates the config, wires WSAA authentication and SOAP transport,
+ * and returns an object with `issue()`, `preview()`, `issueCreditNote()`,
+ * `issueDebitNote()`, `previewCreditNote()`, `previewDebitNote()`, `recover()`
+ * and the `.wsfe`, `.wsmtxca`, and `.padron` service modules.
+ *
+ * @throws {ArcaConfigurationError} When the config is missing or invalid.
+ */
+declare function createArcaClient(config?: ArcaClientOptions): ArcaClient;
+
+export { type ArcaClient as A, type CreditNoteInput as C, type DebitNoteInput as D, type ExactIssueInput as E, type FceOptions as F, type InvoiceFamily as I, type PeriodNoteInput as P, type Receiver as R, type Tribute as T, type VatItem as V, type WsfeIdentityMatch as W, type AmountItem as a, type ArcaClientConfigView as b, type IssuanceFields as c, type IssuanceService as d, type IssueAmounts as e, type IssueCommon as f, type IssueInput as g, type IssueOptions as h, type IssueOutcome as i, type IssuePreview as j, type IssuedVoucher as k, type PreviewOptions as l, type RecoveryOptions as m, type VatRate as n, type VoucherAmounts as o, type VoucherCoordinates as p, type VoucherItemDetail as q, type VoucherSummary as r, type VouchersService as s, type WsmtxcaIssueRequest as t, createArcaClient as u, matchWsfeVoucherIdentity as v };

package/dist/constants.d.ts

@@ -60,7 +60,7 @@ declare const ARCA_CURRENCIES: {
     readonly PES: "PES";
     readonly DOL: "DOL";
 };
-/** Legal assertions supported by the invoice facade; never inferred from Padrón. */
+/** Legal assertions supported by the invoice high-level API; never inferred from Padrón. */
 type IssuerCondition = "responsable_inscripto" | "monotributo" | "exento" | "no_alcanzado";
 type ReceiverCondition = IssuerCondition | "consumidor_final";
 type VoucherClass = "A" | "B" | "C";

package/dist/constants.mjs

@@ -11,7 +11,7 @@ import {
   ARCA_VAT_RATES,
   ARCA_VOUCHER_TYPES,
   ISO_CURRENCIES
-} from "./chunk-76WU5BVI.mjs";
+} from "./chunk-GX5ERXT6.mjs";
 export {
   ARCA_CONCEPT_TYPES,
   ARCA_CURRENCIES,

package/dist/{wsfe-DF0jAE2k.d.ts → decimal-B0HtrMFY.d.ts}

@@ -1,6 +1,6 @@
-import { h as ArcaClientConfig } from './types-BiznC1-X.js';
-import { W as WsaaAuthModule, S as SoapTransport } from './index-CVGQyyYM.js';
-import { A as ArcaAuthorizationOutcome, t as ArcaVoucherLookupResult } from './fiscal-evidence-DBzakqBE.js';
+import { a as ArcaClientConfig } from './types-r2nf55gh.js';
+import { W as WsaaAuthModule, S as SoapTransport } from './index-D8LGFvxV.js';
+import { A as ArcaAuthorizationOutcome, a as ArcaVoucherLookupResult } from './fiscal-evidence-B1Qe6XMg.js';
 
 /** Accepted public date inputs for WSFE request fields. */
 type WsfeDateInput = `${number}${number}${number}${number}-${number}${number}-${number}${number}` | `${number}${number}${number}${number}${number}${number}${number}${number}`;
@@ -82,13 +82,6 @@ type WsfeAuthorizeVoucherInput = {
     voucherNumber: number;
     forceRefresh?: boolean;
 };
-/** Result of a successful WSFE voucher authorization. */
-type WsfeAuthorizationResult = {
-    cae: string;
-    caeExpiry: string;
-    voucherNumber: number;
-    raw: Record<string, unknown>;
-};
 /** Structured evidence from one exact WSFE authorization attempt. */
 type WsfeAuthorizationOutcome = ArcaAuthorizationOutcome<"wsfe">;
 /** A point-of-sale entry returned by {@link WsfeService.getSalesPoints}. */
@@ -125,6 +118,11 @@ type WsfeVoucherInfo = {
     paymentDueDate?: string;
     taxes?: WsfeTax[];
     associatedVouchers?: WsfeAssociatedVoucher[];
+    associatedPeriod?: WsfeAssociatedPeriod;
+    optionalFields?: WsfeOptionalField[];
+    buyers?: WsfeBuyer[];
+    activities?: WsfeActivity[];
+    sameCurrencyForeignCancellation?: "S" | "N";
     raw: Record<string, unknown>;
 };
 /** Typed exact-voucher consultation result for WSFE. */
@@ -163,23 +161,6 @@ type WsfeService = {
      * (`authorized`, `rejected` or `indeterminate`) instead of throwing.
      */
     issue(input: WsfeAuthorizeVoucherInput): Promise<WsfeAuthorizationOutcome>;
-    /** @deprecated Renamed to `issue()`. Removed in the next minor release. */
-    authorizeVoucherOutcome(input: WsfeAuthorizeVoucherInput): Promise<WsfeAuthorizationOutcome>;
-    /**
-     * @deprecated Throws instead of returning evidence, which loses the
-     * rejected/indeterminate distinction. Use `issue()`. Removed in the next
-     * minor release.
-     */
-    authorizeVoucher(input: WsfeAuthorizeVoucherInput): Promise<WsfeAuthorizationResult>;
-    /**
-     * @deprecated Reads the next number and authorizes in one non-idempotent
-     * call. Use `client.issue()` or reserve a number and call `wsfe.issue()`.
-     */
-    createNextVoucher(input: {
-        representedTaxId?: number | string;
-        data: WsfeVoucherInput;
-        forceRefresh?: boolean;
-    }): Promise<WsfeAuthorizationResult>;
     /** Returns the next available voucher number for the given sales point and type. */
     getNextVoucherNumber(input: {
         representedTaxId?: number | string;
@@ -284,42 +265,4 @@ declare function createWsfeService(options: CreateWsfeServiceOptions): WsfeServi
 declare const SUPPORTED_VAT_RATES: readonly [0, 2.5, 5, 10.5, 21, 27];
 type SupportedVatRate = (typeof SUPPORTED_VAT_RATES)[number];
 
-type WsfeBuilderCurrencyInput = {
-    currency?: "ARS";
-    exchangeRate?: never;
-    sameCurrencyForeignCancellation?: never;
-} | {
-    currency: "USD";
-    exchangeRate: string;
-    sameCurrencyForeignCancellation?: false;
-} | {
-    currency: "USD";
-    exchangeRate?: never;
-    sameCurrencyForeignCancellation: true;
-};
-type WsfeBuilderVatRate = SupportedVatRate;
-type WsfeInvoiceBuilderBaseInput = {
-    salesPoint: number;
-    concept: number;
-    documentType: number;
-    documentNumber: number;
-    receiverVatConditionId: number;
-    voucherDate: WsfeDateInput;
-    serviceStartDate?: WsfeDateInput;
-    serviceEndDate?: WsfeDateInput;
-    paymentDueDate?: WsfeDateInput;
-};
-type BuildFacturaBInput = WsfeInvoiceBuilderBaseInput & WsfeBuilderCurrencyInput & {
-    /** Positive integer currency minor units forming the taxable base. */
-    taxableAmount: number;
-    vatRate: WsfeBuilderVatRate;
-};
-type BuildFacturaCInput = WsfeInvoiceBuilderBaseInput & WsfeBuilderCurrencyInput & {
-    amount: number;
-};
-/** Builds a narrow Factura B exact WSFE input from integer currency minor units. */
-declare function buildFacturaB(input: BuildFacturaBInput): WsfeVoucherInput;
-/** Builds a narrow Factura C exact WSFE input from integer currency minor units. */
-declare function buildFacturaC(input: BuildFacturaCInput): WsfeVoucherInput;
-
-export { createWsfeService as A, type BuildFacturaBInput as B, type CreateWsfeServiceOptions as C, type SupportedVatRate as S, type WsfeVoucherInput as W, type WsfeVoucherInfo as a, type WsfeDateInput as b, type WsfeService as c, type BuildFacturaCInput as d, type WsfeActivity as e, type WsfeActivityType as f, type WsfeAssociatedPeriod as g, type WsfeAssociatedVoucher as h, type WsfeAuthorizationOutcome as i, type WsfeAuthorizationResult as j, type WsfeAuthorizeVoucherInput as k, type WsfeBuilderCurrencyInput as l, type WsfeBuilderVatRate as m, type WsfeBuyer as n, type WsfeCatalogEntry as o, type WsfeCurrencyType as p, type WsfeOptionalField as q, type WsfeQuotation as r, type WsfeReceiverVatCondition as s, type WsfeSalesPoint as t, type WsfeServerStatus as u, type WsfeTax as v, type WsfeVatRate as w, type WsfeVoucherLookupResult as x, buildFacturaB as y, buildFacturaC as z };
+export { type CreateWsfeServiceOptions as C, type SupportedVatRate as S, type WsfeActivity as W, type WsfeActivityType as a, type WsfeAssociatedPeriod as b, type WsfeAssociatedVoucher as c, type WsfeAuthorizationOutcome as d, type WsfeAuthorizeVoucherInput as e, type WsfeBuyer as f, type WsfeCatalogEntry as g, type WsfeCurrencyType as h, type WsfeDateInput as i, type WsfeOptionalField as j, type WsfeQuotation as k, type WsfeReceiverVatCondition as l, type WsfeSalesPoint as m, type WsfeServerStatus as n, type WsfeService as o, type WsfeTax as p, type WsfeVatRate as q, type WsfeVoucherInfo as r, type WsfeVoucherInput as s, type WsfeVoucherLookupResult as t, createWsfeService as u };

package/dist/errors.d.ts

@@ -1,2 +1,2 @@
-import './types-BiznC1-X.js';
-export { c as ArcaAuthenticationError, d as ArcaAuthenticationErrorOptions, f as ArcaAuthenticationReason, h as ArcaConfigurationError, i as ArcaError, m as ArcaInputError, n as ArcaInputErrorCode, o as ArcaInputErrorOptions, p as ArcaInvalidSoapResponseError, b as ArcaSafeErrorMetadata, q as ArcaServiceError, r as ArcaSoapFaultError, s as ArcaTransportError, u as isArcaAuthenticationError, v as toArcaSafeErrorMetadata } from './fiscal-evidence-DBzakqBE.js';
+import './types-r2nf55gh.js';
+export { b as ArcaAuthenticationError, c as ArcaAuthenticationErrorOptions, e as ArcaAuthenticationReason, g as ArcaConfigurationError, h as ArcaError, m as ArcaInputError, n as ArcaInputErrorCode, o as ArcaInputErrorOptions, p as ArcaInvalidSoapResponseError, q as ArcaSafeErrorMetadata, r as ArcaServiceError, s as ArcaSoapFaultError, t as ArcaTransportError, u as isArcaAuthenticationError, v as toArcaSafeErrorMetadata } from './fiscal-evidence-B1Qe6XMg.js';

package/dist/{fiscal-evidence-DBzakqBE.d.ts → fiscal-evidence-B1Qe6XMg.d.ts}

@@ -1,4 +1,4 @@
-import { A as ArcaServiceName } from './types-BiznC1-X.js';
+import { b as ArcaServiceName } from './types-r2nf55gh.js';
 
 /** Base error class for all ARCA-related errors. */
 declare class ArcaError extends Error {
@@ -194,4 +194,4 @@ type ArcaVoucherLookupResult<TVoucher, TService extends ArcaFiscalService = Arca
     raw: Record<string, unknown>;
 };
 
-export { type ArcaAuthorizationOutcome as A, type ArcaFiscalIssue as a, type ArcaSafeErrorMetadata as b, ArcaAuthenticationError as c, type ArcaAuthenticationErrorOptions as d, type ArcaAuthenticationEvidence as e, type ArcaAuthenticationReason as f, type ArcaAuthorizationIndeterminateReason as g, ArcaConfigurationError as h, ArcaError as i, type ArcaFiscalResultLevel as j, type ArcaFiscalResults as k, type ArcaFiscalService as l, ArcaInputError as m, type ArcaInputErrorCode as n, type ArcaInputErrorOptions as o, ArcaInvalidSoapResponseError as p, ArcaServiceError as q, ArcaSoapFaultError as r, ArcaTransportError as s, type ArcaVoucherLookupResult as t, isArcaAuthenticationError as u, toArcaSafeErrorMetadata as v };
+export { type ArcaAuthorizationOutcome as A, type ArcaVoucherLookupResult as a, ArcaAuthenticationError as b, type ArcaAuthenticationErrorOptions as c, type ArcaAuthenticationEvidence as d, type ArcaAuthenticationReason as e, type ArcaAuthorizationIndeterminateReason as f, ArcaConfigurationError as g, ArcaError as h, type ArcaFiscalIssue as i, type ArcaFiscalResultLevel as j, type ArcaFiscalResults as k, type ArcaFiscalService as l, ArcaInputError as m, type ArcaInputErrorCode as n, type ArcaInputErrorOptions as o, ArcaInvalidSoapResponseError as p, type ArcaSafeErrorMetadata as q, ArcaServiceError as r, ArcaSoapFaultError as s, ArcaTransportError as t, isArcaAuthenticationError as u, toArcaSafeErrorMetadata as v };

package/dist/{index-CVGQyyYM.d.ts → index-D8LGFvxV.d.ts}

@@ -1,4 +1,4 @@
-import { a as ArcaSoapExecutionOptions, b as ArcaSoapResponse, c as ArcaWsaaServiceId, d as ArcaAuthOptions, e as ArcaAuthCredentials } from './types-BiznC1-X.js';
+import { c as ArcaSoapExecutionOptions, d as ArcaSoapResponse, e as ArcaWsaaServiceId, f as ArcaAuthOptions, g as ArcaAuthCredentials } from './types-r2nf55gh.js';
 
 type SoapTransport = {
     execute<TBody, TResult>(request: ArcaSoapExecutionOptions<TBody>): Promise<ArcaSoapResponse<TResult>>;