facturas 0.7.1 → 0.9.0

package/dist/constants.d.ts

@@ -60,5 +60,53 @@ declare const ARCA_CURRENCIES: {
     readonly PES: "PES";
     readonly DOL: "DOL";
 };
+/** Legal assertions supported by the invoice facade; never inferred from Padrón. */
+type IssuerCondition = "responsable_inscripto" | "monotributo" | "exento" | "no_alcanzado";
+type ReceiverCondition = IssuerCondition | "consumidor_final";
+type VoucherClass = "A" | "B" | "C";
+declare const ARCA_RECEIVER_CONDITION_IDS: {
+    readonly responsable_inscripto: 1;
+    readonly monotributo: 6;
+    readonly exento: 4;
+    readonly consumidor_final: 5;
+    readonly no_alcanzado: 15;
+};
+declare const ARCA_ISSUER_CONDITION_IDS: {
+    readonly responsable_inscripto: 1;
+    readonly monotributo: 6;
+    readonly exento: 4;
+    readonly no_alcanzado: 15;
+};
+declare const ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS = 1000000000n;
+declare const ARCA_INVOICE_CLASS_BY_ISSUER: {
+    readonly responsable_inscripto: {
+        readonly responsable_inscripto: "A";
+        readonly monotributo: "A";
+        readonly exento: "B";
+        readonly consumidor_final: "B";
+        readonly no_alcanzado: "B";
+    };
+    readonly monotributo: {
+        readonly responsable_inscripto: "C";
+        readonly monotributo: "C";
+        readonly exento: "C";
+        readonly consumidor_final: "C";
+        readonly no_alcanzado: "C";
+    };
+    readonly exento: {
+        readonly responsable_inscripto: "C";
+        readonly monotributo: "C";
+        readonly exento: "C";
+        readonly consumidor_final: "C";
+        readonly no_alcanzado: "C";
+    };
+    readonly no_alcanzado: {
+        readonly responsable_inscripto: "C";
+        readonly monotributo: "C";
+        readonly exento: "C";
+        readonly consumidor_final: "C";
+        readonly no_alcanzado: "C";
+    };
+};
 
-export { ARCA_CONCEPT_TYPES, ARCA_CURRENCIES, ARCA_CURRENCY_IDS, ARCA_DOCUMENT_TYPES, ARCA_RECEIVER_VAT_CONDITIONS, ARCA_VAT_RATES, ARCA_VOUCHER_TYPES, ISO_CURRENCIES };
+export { ARCA_CONCEPT_TYPES, ARCA_CURRENCIES, ARCA_CURRENCY_IDS, ARCA_DOCUMENT_TYPES, ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS, ARCA_INVOICE_CLASS_BY_ISSUER, ARCA_ISSUER_CONDITION_IDS, ARCA_RECEIVER_CONDITION_IDS, ARCA_RECEIVER_VAT_CONDITIONS, ARCA_VAT_RATES, ARCA_VOUCHER_TYPES, ISO_CURRENCIES, type IssuerCondition, type ReceiverCondition, type VoucherClass };

package/dist/constants.mjs

@@ -3,16 +3,24 @@ import {
   ARCA_CURRENCIES,
   ARCA_CURRENCY_IDS,
   ARCA_DOCUMENT_TYPES,
+  ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS,
+  ARCA_INVOICE_CLASS_BY_ISSUER,
+  ARCA_ISSUER_CONDITION_IDS,
+  ARCA_RECEIVER_CONDITION_IDS,
   ARCA_RECEIVER_VAT_CONDITIONS,
   ARCA_VAT_RATES,
   ARCA_VOUCHER_TYPES,
   ISO_CURRENCIES
-} from "./chunk-VVY2LZIZ.mjs";
+} from "./chunk-76WU5BVI.mjs";
 export {
   ARCA_CONCEPT_TYPES,
   ARCA_CURRENCIES,
   ARCA_CURRENCY_IDS,
   ARCA_DOCUMENT_TYPES,
+  ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS,
+  ARCA_INVOICE_CLASS_BY_ISSUER,
+  ARCA_ISSUER_CONDITION_IDS,
+  ARCA_RECEIVER_CONDITION_IDS,
   ARCA_RECEIVER_VAT_CONDITIONS,
   ARCA_VAT_RATES,
   ARCA_VOUCHER_TYPES,

package/dist/errors.d.ts

@@ -1,2 +1,2 @@
-import './types-BXq0da71.js';
-export { A as ArcaAuthenticationError, a as ArcaAuthenticationErrorOptions, c as ArcaAuthenticationReason, f as ArcaConfigurationError, g as ArcaError, l as ArcaInputError, m as ArcaInputErrorCode, n as ArcaInputErrorOptions, o as ArcaInvalidSoapResponseError, p as ArcaServiceError, q as ArcaSoapFaultError, r as ArcaTransportError, t as isArcaAuthenticationError } from './fiscal-evidence-BQuBbJ3h.js';
+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';

package/dist/errors.mjs

@@ -7,8 +7,9 @@ import {
   ArcaServiceError,
   ArcaSoapFaultError,
   ArcaTransportError,
-  isArcaAuthenticationError
-} from "./chunk-MBWOFO67.mjs";
+  isArcaAuthenticationError,
+  toArcaSafeErrorMetadata
+} from "./chunk-ZOSNASXB.mjs";
 export {
   ArcaAuthenticationError,
   ArcaConfigurationError,
@@ -18,6 +19,7 @@ export {
   ArcaServiceError,
   ArcaSoapFaultError,
   ArcaTransportError,
-  isArcaAuthenticationError
+  isArcaAuthenticationError,
+  toArcaSafeErrorMetadata
 };
 //# sourceMappingURL=errors.mjs.map

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

@@ -1,4 +1,4 @@
-import { A as ArcaServiceName } from './types-BXq0da71.js';
+import { A as ArcaServiceName } from './types-BiznC1-X.js';
 
 /** Base error class for all ARCA-related errors. */
 declare class ArcaError extends Error {
@@ -12,7 +12,7 @@ declare class ArcaConfigurationError extends ArcaError {
     constructor(message: string, options?: ErrorOptions);
 }
 /** Stable routing codes for caller-provided input failures. */
-type ArcaInputErrorCode = "ARCA_INPUT_INVALID_DATE" | "ARCA_INPUT_INVALID_AMOUNT" | "ARCA_INPUT_AMOUNT_PRECISION" | "ARCA_INPUT_AMOUNT_MISMATCH" | "ARCA_INPUT_INVALID_EXCHANGE_RATE" | "ARCA_INPUT_INVALID_VALUE" | "ARCA_INPUT_MISSING_FIELD" | "ARCA_INPUT_RESERVED_FIELD";
+type ArcaInputErrorCode = "ARCA_INPUT_IDEMPOTENCY_MISMATCH" | "ARCA_INPUT_INVALID_DATE" | "ARCA_INPUT_INVALID_AMOUNT" | "ARCA_INPUT_AMOUNT_PRECISION" | "ARCA_INPUT_AMOUNT_MISMATCH" | "ARCA_INPUT_INVALID_EXCHANGE_RATE" | "ARCA_INPUT_INVALID_VALUE" | "ARCA_INPUT_MISSING_FIELD" | "ARCA_INPUT_RESERVED_FIELD";
 type ArcaInputErrorOptions = ErrorOptions & {
     code: ArcaInputErrorCode;
     field?: string;
@@ -110,6 +110,14 @@ declare class ArcaServiceError extends ArcaError {
         issues?: readonly ArcaFiscalIssue[];
     });
 }
+/** Narrow error evidence: never includes a cause, raw response or stack. */
+type ArcaSafeErrorMetadata = {
+    name: string;
+    message: string;
+    code?: string;
+    statusCode?: number;
+};
+declare function toArcaSafeErrorMetadata(error: unknown): ArcaSafeErrorMetadata;
 
 /** ARCA services that authorize fiscal vouchers. */
 type ArcaFiscalService = "wsfe" | "wsmtxca";
@@ -186,4 +194,4 @@ type ArcaVoucherLookupResult<TVoucher, TService extends ArcaFiscalService = Arca
     raw: Record<string, unknown>;
 };
 
-export { ArcaAuthenticationError as A, type ArcaAuthenticationErrorOptions as a, type ArcaAuthenticationEvidence as b, type ArcaAuthenticationReason as c, type ArcaAuthorizationIndeterminateReason as d, type ArcaAuthorizationOutcome as e, ArcaConfigurationError as f, ArcaError as g, type ArcaFiscalIssue as h, type ArcaFiscalResultLevel as i, type ArcaFiscalResults as j, type ArcaFiscalService as k, ArcaInputError as l, type ArcaInputErrorCode as m, type ArcaInputErrorOptions as n, ArcaInvalidSoapResponseError as o, ArcaServiceError as p, ArcaSoapFaultError as q, ArcaTransportError as r, type ArcaVoucherLookupResult as s, isArcaAuthenticationError as t };
+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 };

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

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

package/dist/index.d.ts

@@ -1,13 +1,209 @@
-import { f as ArcaEnvironment, g as ArcaClientConfig, h as ArcaWsaaSessionStore } from './types-BXq0da71.js';
-export { e as ArcaAuthCredentials, d as ArcaAuthOptions, i as ArcaLogLevel, j as ArcaLoggerConfig, k as ArcaPadronServiceName, l as ArcaRepresentedTaxId, A as ArcaServiceName, m as ArcaServiceTarget, c as ArcaWsaaServiceId, n as ArcaWsaaSessionKey } from './types-BXq0da71.js';
+import { f as ArcaEnvironment, g as ArcaClientOptions, h as ArcaClientConfig, i as ArcaStore, j as ArcaWsaaSessionStore } from './types-BiznC1-X.js';
+export { e as ArcaAuthCredentials, d as ArcaAuthOptions, k as ArcaLogLevel, l as ArcaLoggerConfig, m as ArcaPadronServiceName, n as ArcaRepresentedTaxId, A as ArcaServiceName, o as ArcaServiceTarget, c as ArcaWsaaServiceId, p as ArcaWsaaSessionKey } from './types-BiznC1-X.js';
 import { PadronService } from './padron.js';
 export { CreatePadronServiceOptions, PadronTaxIdLookupResult, PadronTaxpayerResult, createPadronService } from './padron.js';
-import { WsfeService } from './wsfe.js';
-export { BuildFacturaBInput, BuildFacturaCInput, CreateWsfeServiceOptions, WsfeActivity, WsfeActivityType, WsfeAssociatedPeriod, WsfeAssociatedVoucher, WsfeAuthorizationOutcome, WsfeAuthorizationResult, WsfeAuthorizeVoucherInput, WsfeBuilderCurrencyInput, WsfeBuilderVatRate, WsfeBuyer, WsfeCatalogEntry, WsfeCurrencyType, WsfeDateInput, WsfeOptionalField, WsfeQuotation, WsfeReceiverVatCondition, WsfeSalesPoint, WsfeServerStatus, WsfeTax, WsfeVatRate, WsfeVoucherInfo, WsfeVoucherInput, WsfeVoucherLookupResult, buildFacturaB, buildFacturaC, createWsfeService } from './wsfe.js';
+import { S as SupportedVatRate, W as WsfeVoucherInput, a as WsfeVoucherInfo, b as WsfeDateInput, c as WsfeService } from './wsfe-DF0jAE2k.js';
+export { B as BuildFacturaBInput, d as BuildFacturaCInput, C as CreateWsfeServiceOptions, e as WsfeActivity, f as WsfeActivityType, g as WsfeAssociatedPeriod, h as WsfeAssociatedVoucher, i as WsfeAuthorizationOutcome, j as WsfeAuthorizationResult, k as WsfeAuthorizeVoucherInput, l as WsfeBuilderCurrencyInput, m as WsfeBuilderVatRate, n as WsfeBuyer, o as WsfeCatalogEntry, p as WsfeCurrencyType, q as WsfeOptionalField, r as WsfeQuotation, s as WsfeReceiverVatCondition, t as WsfeSalesPoint, u as WsfeServerStatus, v as WsfeTax, w as WsfeVatRate, x as WsfeVoucherLookupResult, y as buildFacturaB, z as buildFacturaC, A as createWsfeService } from './wsfe-DF0jAE2k.js';
+import { VoucherClass, ReceiverCondition } from './constants.js';
+export { ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS, ARCA_INVOICE_CLASS_BY_ISSUER, ARCA_ISSUER_CONDITION_IDS, ARCA_RECEIVER_CONDITION_IDS, IssuerCondition } from './constants.js';
+import { A as ArcaAuthorizationOutcome, a as ArcaFiscalIssue, b as ArcaSafeErrorMetadata } from './fiscal-evidence-DBzakqBE.js';
+export { c as ArcaAuthenticationError, d as ArcaAuthenticationErrorOptions, e as ArcaAuthenticationEvidence, f as ArcaAuthenticationReason, g as ArcaAuthorizationIndeterminateReason, h as ArcaConfigurationError, i as ArcaError, j as ArcaFiscalResultLevel, k as ArcaFiscalResults, l as ArcaFiscalService, m as ArcaInputError, n as ArcaInputErrorCode, o as ArcaInputErrorOptions, p as ArcaInvalidSoapResponseError, q as ArcaServiceError, r as ArcaSoapFaultError, s as ArcaTransportError, t as ArcaVoucherLookupResult, u as isArcaAuthenticationError, v as toArcaSafeErrorMetadata } from './fiscal-evidence-DBzakqBE.js';
 import { WsmtxcaService } from './wsmtxca.js';
 export { CreateWsmtxcaServiceOptions, WsmtxcaAuthorizationOutcome, WsmtxcaAuthorizationResult, WsmtxcaAuthorizeVoucherInput, WsmtxcaLastAuthorizedVoucherResult, WsmtxcaSalesPoint, WsmtxcaSalesPointsResult, WsmtxcaVoucherInfo, WsmtxcaVoucherLookupOutcome, WsmtxcaVoucherLookupResult, createWsmtxcaService } from './wsmtxca.js';
-export { A as ArcaAuthenticationError, a as ArcaAuthenticationErrorOptions, b as ArcaAuthenticationEvidence, c as ArcaAuthenticationReason, d as ArcaAuthorizationIndeterminateReason, e as ArcaAuthorizationOutcome, f as ArcaConfigurationError, g as ArcaError, h as ArcaFiscalIssue, i as ArcaFiscalResultLevel, j as ArcaFiscalResults, k as ArcaFiscalService, l as ArcaInputError, m as ArcaInputErrorCode, n as ArcaInputErrorOptions, o as ArcaInvalidSoapResponseError, p as ArcaServiceError, q as ArcaSoapFaultError, r as ArcaTransportError, s as ArcaVoucherLookupResult, t as isArcaAuthenticationError } from './fiscal-evidence-BQuBbJ3h.js';
-import './index-CVpygFb0.js';
+import './index-CVGQyyYM.js';
+
+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(). This proves
+ * consistency, not authorship. Configure a store and pass idempotencyKey for retries.
+ * Unsupported exact-API extensions are incomplete.
+ */
+declare function matchWsfeVoucherIdentity(sent: WsfeVoucherInput, number: number, found: WsfeVoucherInfo): WsfeIdentityMatch;
+
+type IssueOptions = {
+    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;
+};
+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: WsfeVoucherInput;
+} : true extends NonNullable<O["include"]>["exactInput"] ? {
+    sent?: WsfeVoucherInput;
+} : unknown;
+type Evidence<K extends ArcaAuthorizationOutcome<"wsfe">["kind"], O extends IssueOptions> = WithRaw<Omit<Extract<ArcaAuthorizationOutcome<"wsfe">, {
+    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;
+};
+
+type Receiver = {
+    condition: "consumidor_final";
+    cuit?: number | string;
+    dni?: number | string;
+} | {
+    condition: Exclude<ReceiverCondition, "consumidor_final">;
+    cuit: number | string;
+    dni?: never;
+};
+type IssueCommon = {
+    salesPoint: number;
+    to: Receiver;
+    total?: number;
+    date?: WsfeDateInput;
+    currency?: "ARS" | "USD";
+    exchangeRate?: string;
+    service?: {
+        from: WsfeDateInput;
+        to: WsfeDateInput;
+        dueDate: WsfeDateInput;
+    };
+};
+type IssueInput = IssueCommon & ({
+    issuer: "responsable_inscripto";
+    items: readonly VatItem[];
+} | {
+    issuer: "monotributo" | "exento" | "no_alcanzado";
+    items: readonly AmountItem[];
+});
+
+type VouchersService = {
+    /** Creates a full credit note associated to an authorized A, B or C invoice. */
+    cancel<O extends IssueOptions & {
+        date?: WsfeDateInput;
+    } = {
+        include?: never;
+    }>(target: VoucherCoordinates, 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>>;
+};
 
 /** Immutable, credential-free operational view of an ARCA client configuration. */
 type ArcaClientConfigView = Readonly<{
@@ -20,6 +216,10 @@ type ArcaClientConfigView = Readonly<{
 /** 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"];
+    /** Issues a full credit note against an authorized invoice. */
+    cancel: VouchersService["cancel"];
     wsfe: WsfeService;
     wsmtxca: WsmtxcaService;
     padron: PadronService;
@@ -27,11 +227,11 @@ type ArcaClient = {
 /**
  * Creates an ARCA client from the given configuration.
  * Validates the config, wires WSAA authentication and SOAP transport,
- * and returns an object with `.wsfe`, `.wsmtxca`, and `.padron` service modules.
+ * and returns an object with `issue()`, `cancel()` and the `.wsfe`, `.wsmtxca`, and `.padron` service modules.
  *
  * @throws {ArcaConfigurationError} When the config is missing or invalid.
  */
-declare function createArcaClient(config: ArcaClientConfig): ArcaClient;
+declare function createArcaClient(config?: ArcaClientOptions): ArcaClient;
 
 /** Valid ARCA environment names. */
 declare const ARCA_ENVIRONMENTS: readonly ["production", "test"];
@@ -65,6 +265,35 @@ declare function createArcaClientConfigFromEnv(options?: CreateArcaClientConfigF
  */
 declare function assertArcaClientConfig(config: ArcaClientConfig): void;
 
+/** Persistent store for a single server with a private durable volume. */
+declare function createFileStore(directory: string): ArcaStore;
+
+/** In-process store for tests; reservations do not survive a restart. */
+declare function createMemoryStore(): ArcaStore;
+
+type Row = {
+    key?: string;
+    value?: string;
+};
+/** Uses the caller's SQL client; provision the table before use. */
+declare function createPostgresStore({ query, table, }: {
+    query: (text: string, params: string[]) => Promise<Row[] | {
+        rows: Row[];
+    }>;
+    table?: string;
+}): ArcaStore;
+
+type RedisClient = {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: string): Promise<unknown>;
+    call?(...args: string[]): Promise<unknown>;
+    del?(key: string): Promise<unknown>;
+};
+/** Uses ioredis or Upstash without importing either driver. */
+declare function createRedisStore(client: RedisClient, options?: {
+    flavor?: "ioredis" | "upstash";
+}): ArcaStore;
+
 declare function createMemoryWsaaSessionStore(): ArcaWsaaSessionStore;
 
-export { ARCA_ENVIRONMENTS, ARCA_ENV_VARIABLES, type ArcaClient, ArcaClientConfig, type ArcaClientConfigView, ArcaEnvironment, ArcaWsaaSessionStore, type CreateArcaClientConfigFromEnvOptions, PadronService, WsfeService, WsmtxcaService, assertArcaClientConfig, createArcaClient, createArcaClientConfigFromEnv, createMemoryWsaaSessionStore, resolveArcaEnvironment };
+export { ARCA_ENVIRONMENTS, ARCA_ENV_VARIABLES, type AmountItem, ArcaAuthorizationOutcome, type ArcaClient, ArcaClientOptions as ArcaClientConfig, type ArcaClientConfigView, ArcaEnvironment, ArcaFiscalIssue, ArcaSafeErrorMetadata, ArcaStore, ArcaWsaaSessionStore, type CreateArcaClientConfigFromEnvOptions, type IssueAmounts, type IssueCommon, type IssueInput, type IssueOptions, type IssueOutcome, type IssuedVoucher, PadronService, type Receiver, ReceiverCondition, type VatItem, type VatRate, VoucherClass, type VoucherCoordinates, type VoucherSummary, type VouchersService, WsfeDateInput, type WsfeIdentityMatch, WsfeService, WsfeVoucherInfo, WsfeVoucherInput, WsmtxcaService, assertArcaClientConfig, createArcaClient, createArcaClientConfigFromEnv, createFileStore, createMemoryStore, createMemoryWsaaSessionStore, createPostgresStore, createRedisStore, matchWsfeVoucherIdentity, resolveArcaEnvironment };