@deuriib/better-dgii-ecf 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deuri Vasquez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.es.md

@@ -0,0 +1,159 @@
+# better-dgii-ecf
+
+[English](README.md) · [Español](README.es.md)
+
+> Plugin de [Better Auth](https://better-auth.com) para los servicios de facturación
+> electrónica (**e-CF**) de la **DGII** de República Dominicana, construido sobre
+> [`@deuriib/dgii-ecf`](https://www.npmjs.com/package/@deuriib/dgii-ecf).
+
+[![npm](https://img.shields.io/npm/v/@deuriib/better-dgii-ecf.svg?label=npm)](https://www.npmjs.com/package/@deuriib/better-dgii-ecf)
+[![CI](https://github.com/deuriib/better-dgii-ecf/actions/workflows/ci.yml/badge.svg)](https://github.com/deuriib/better-dgii-ecf/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+`better-dgii-ecf` convierte el SDK de la DGII en una API autenticada. Decide **qué
+contribuyente** actúa en cada petición, resuelve su certificado **en el servidor** y
+registra cada transmisión para que un reintento no pueda emitir dos veces el mismo
+comprobante fiscal.
+
+Es un plugin, no un generador de documentos: tu aplicación modela la factura, el plugin
+se encarga de la identidad, las credenciales, la idempotencia y la auditoría.
+
+## ✨ Por qué existe
+
+Una integración con la DGII tiene tres problemas que el framework de autenticación no
+resuelve:
+
+| Problema                        | Qué pasa sin el plugin                                                               | Qué hace el plugin                                                                                                   |
+| ------------------------------- | ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
+| **¿Quién factura?**             | El RNC viene del navegador, así que cualquiera factura como cualquier contribuyente. | Resuelve el contribuyente desde la organización, la petición o un mapeo del servidor, y luego lo autoriza.           |
+| **¿Dónde vive el certificado?** | El `.p12` termina en el cliente o en cada cuerpo de petición.                        | Resuelve la llave por un callback exclusivo del servidor, firma en el servidor y nunca devuelve el token de la DGII. |
+| **¿Llegó el comprobante?**      | Un timeout más un reintento emite dos veces el mismo e-NCF.                          | Escribe una fila `pending` antes de transmitir y reproduce el envío conocido en vez de repetirlo.                    |
+
+## 📦 Instalación
+
+```bash
+bun add @deuriib/better-dgii-ecf @deuriib/dgii-ecf better-auth
+# o: npm install @deuriib/better-dgii-ecf @deuriib/dgii-ecf better-auth
+```
+
+Dependencias peer: `better-auth@^1.7`, `@deuriib/dgii-ecf@^0.6`.
+
+## 🚀 Inicio rápido — modo organización
+
+El modo recomendado. El `taxPayerId` vive en la organización, así que el RNC con el que
+un usuario puede facturar es el de la organización a la que pertenece.
+
+```ts
+// auth.ts
+import { betterAuth } from 'better-auth';
+import { organization } from 'better-auth/plugins';
+import { P12Reader, Environment } from '@deuriib/dgii-ecf';
+import { dgiiEcf, dgiiEcfOrganizationSchema } from '@deuriib/better-dgii-ecf';
+
+export const auth = betterAuth({
+  plugins: [
+    organization({
+      // Hace escribible el campo `taxPayerId` de la organización.
+      schema: { organization: dgiiEcfOrganizationSchema() },
+    }),
+    dgiiEcf({
+      environment: Environment.Cert,
+      // El único lugar donde se lee un certificado. Se ejecuta en el servidor,
+      // por contribuyente, nunca desde el cuerpo de una petición.
+      credentials: async ({ taxPayerId }) => {
+        const p12 = await certificates.for(taxPayerId); // tu almacenamiento
+        return new P12Reader(p12.password)
+          .getKeyFromStringBase64(p12.base64)
+          .unwrapOrThrow();
+      },
+      status: { apiKey: process.env.DGII_STATUS_API_KEY! },
+    }),
+  ],
+});
+```
+
+```ts
+// auth-client.ts
+import { createAuthClient } from 'better-auth/client';
+import { organizationClient } from 'better-auth/client/plugins';
+import { dgiiEcfClient } from '@deuriib/better-dgii-ecf/client';
+
+export const authClient = createAuthClient({
+  plugins: [organizationClient(), dgiiEcfClient()],
+});
+```
+
+```ts
+const { data, error } = await authClient.dgiiEcf.documents({
+  xml: invoiceXml, // construido por tu aplicación
+  sign: true, // firmado aquí, con la llave de la organización
+});
+```
+
+## 🚀 Inicio rápido — modo por petición
+
+Sin el plugin de organización: cada llamada indica su contribuyente. Es la forma de un
+despliegue de un solo emisor, y funciona porque no hay un modelo de inquilino contra el
+cual comparar el identificador.
+
+```ts
+dgiiEcf({
+  environment: Environment.Dev,
+  credentials: async () => loadSingleTenantCertificate(),
+});
+```
+
+```ts
+await auth.api.dgiiEcfSendDocument({
+  body: { xml, sign: true, taxPayerId: '131123456' },
+  headers,
+});
+```
+
+Ambos modos son de primera clase; el
+[orden de resolución](docs/usage.md#which-taxpayer-does-a-call-act-for) es fijo y
+`GET /dgii-ecf/taxpayer` lo reporta, para que la interfaz nunca tenga que adivinar.
+
+## 🔐 Postura de seguridad
+
+- **Ningún certificado en el navegador.** La llave se resuelve por un callback del
+  servidor; `sign: true` firma dentro del proceso que la tiene.
+- **Ningún token de la DGII en la red.** `authenticate` devuelve `issuedAt` /
+  `expiresAt`; el token no sale del servidor, ni siquiera en un cuerpo de error.
+- **El emisor debe coincidir.** Un documento cuyo `RNCEmisor` difiere del contribuyente
+  autorizado se rechaza.
+- **Idempotente por construcción.** La llave de repetición es el SHA-256 del documento,
+  y la fila `pending` se escribe antes de transmitir.
+- **Nada fiscal en la tabla de auditoría.** Solo un hash, el e-NCF, el track id y la
+  operación.
+
+Lee [docs/security.md](docs/security.md) para el modelo de amenazas, incluido lo que el
+plugin **no** protege a propósito.
+
+## 🧪 Desarrollo
+
+Todo corre por [mise](https://mise.jdx.dev) — local y en CI, con la misma cadena de
+herramientas fijada.
+
+```bash
+mise install          # Node, Bun, pre-commit y gitleaks
+mise run bootstrap    # dependencias + git hooks
+mise run ci           # formato + tipos + cobertura + build + chequeos del paquete
+mise tasks            # lista todas las tareas
+```
+
+## 📚 Documentación
+
+- [Guía de uso](docs/usage.md) — modos, endpoints, repetición, errores
+- [Arquitectura](docs/architecture.md) — ciclo de vida y modelo de datos
+- [Seguridad](docs/security.md) — modelo de amenazas y garantías
+- [Decisiones](docs/decisions.md) — por qué los valores por defecto son estos
+- [Contribuir](CONTRIBUTING.md) · [Código de Conducta](CODE_OF_CONDUCT.md)
+
+## ⚖️ Licencia
+
+[MIT](LICENSE) © 2026 Deuri Vasquez.
+
+> No está afiliado a la DGII. Es una implementación independiente de la especificación
+> técnica pública del e-CF (Ley 32-23, Decreto 587-24). Valida siempre contra la
+> [documentación oficial](https://dgii.gov.do/cicloContribuyente/facturacion/comprobantesFiscalesElectronicosE-CF/Paginas/default.aspx).

package/README.md

@@ -1,3 +1,197 @@
-# Temporary Holding Version
+# better-dgii-ecf
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[English](README.md) · [Español](README.es.md)
+
+> A [Better Auth](https://better-auth.com) plugin for the Dominican Republic's **DGII**
+> electronic invoicing (e-CF) services, built on
+> [`@deuriib/dgii-ecf`](https://www.npmjs.com/package/@deuriib/dgii-ecf).
+
+[![npm](https://img.shields.io/npm/v/@deuriib/better-dgii-ecf.svg?label=npm)](https://www.npmjs.com/package/@deuriib/better-dgii-ecf)
+[![CI](https://github.com/deuriib/better-dgii-ecf/actions/workflows/ci.yml/badge.svg)](https://github.com/deuriib/better-dgii-ecf/actions/workflows/ci.yml)
+[![CodeQL](https://github.com/deuriib/better-dgii-ecf/actions/workflows/codeql.yml/badge.svg)](https://github.com/deuriib/better-dgii-ecf/actions/workflows/codeql.yml)
+[![npm provenance](https://img.shields.io/badge/provenance-OIDC-blue)](https://docs.npmjs.com/trusted-publishers)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://www.conventionalcommits.org/)
+
+`better-dgii-ecf` turns the DGII SDK into an authenticated API surface. It decides
+**which taxpayer** a request acts for, resolves that taxpayer's certificate
+**server-side**, and records every transmission so a retry can never issue the same
+fiscal document twice.
+
+It is a plugin, not a document builder: your application owns the invoice model, the
+plugin owns identity, credentials, replay safety and the audit trail.
+
+## ✨ Why this plugin exists
+
+A DGII integration has three problems that authentication frameworks do not solve:
+
+| Problem                              | What goes wrong without it                                               | What the plugin does                                                                                     |
+| ------------------------------------ | ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
+| **Who is invoicing?**                | The RNC comes from the browser, so any user can invoice as any taxpayer. | Resolves the taxpayer from the organization, the request, or a server-side mapping — then authorizes it. |
+| **Where does the certificate live?** | The `.p12` ends up in the client, or in every request body.              | Resolves key material through a server-only callback; signs server-side; never returns a DGII token.     |
+| **Did the invoice land?**            | A timeout plus a retry issues the same e-NCF twice.                      | Persists a pending row before transmitting and replays a known submission instead of re-sending it.      |
+
+## 📦 Install
+
+```bash
+bun add @deuriib/better-dgii-ecf @deuriib/dgii-ecf better-auth
+# or: npm install @deuriib/better-dgii-ecf @deuriib/dgii-ecf better-auth
+```
+
+Peer dependencies: `better-auth@^1.7`, `@deuriib/dgii-ecf@^0.6`.
+
+## 🚀 Quick start — organization mode
+
+The recommended setup. `taxPayerId` lives on the organization, so the RNC a user can
+invoice under is the organization they belong to.
+
+```ts
+// auth.ts
+import { betterAuth } from 'better-auth';
+import { organization } from 'better-auth/plugins';
+import { P12Reader, Environment } from '@deuriib/dgii-ecf';
+import { dgiiEcf, dgiiEcfOrganizationSchema } from '@deuriib/better-dgii-ecf';
+
+export const auth = betterAuth({
+  plugins: [
+    organization({
+      // Makes `taxPayerId` writable on the organization (create + update).
+      schema: { organization: dgiiEcfOrganizationSchema() },
+    }),
+    dgiiEcf({
+      environment: Environment.Cert,
+      // The only place a certificate is ever read. Called server-side, once per
+      // taxpayer, never from a request body.
+      credentials: async ({ taxPayerId }) => {
+        const p12 = await certificates.for(taxPayerId); // your storage
+        return new P12Reader(p12.password)
+          .getKeyFromStringBase64(p12.base64)
+          .unwrapOrThrow();
+      },
+      status: { apiKey: process.env.DGII_STATUS_API_KEY! },
+    }),
+  ],
+});
+```
+
+```ts
+// auth-client.ts
+import { createAuthClient } from 'better-auth/client';
+import { organizationClient } from 'better-auth/client/plugins';
+import { dgiiEcfClient } from '@deuriib/better-dgii-ecf/client';
+
+export const authClient = createAuthClient({
+  plugins: [organizationClient(), dgiiEcfClient()],
+});
+```
+
+```ts
+const { data, error } = await authClient.dgiiEcf.documents({
+  xml: invoiceXml, // built by your application
+  sign: true, // signed here, with the organization's key
+});
+```
+
+## 🚀 Quick start — per-call mode
+
+No organization plugin: every call names its taxpayer. This is the single-tenant shape,
+and it works because there is no tenant model to check the id against.
+
+```ts
+dgiiEcf({
+  environment: Environment.Dev,
+  credentials: async () => loadSingleTenantCertificate(),
+});
+```
+
+```ts
+await auth.api.dgiiEcfSendDocument({
+  body: { xml, sign: true, taxPayerId: '131123456' },
+  headers,
+});
+```
+
+Both modes are first class;
+[the resolution order](docs/usage.md#which-taxpayer-does-a-call-act-for) is fixed and
+reported back by `GET /dgii-ecf/taxpayer`, so a UI never has to guess.
+
+## 🔌 What you get
+
+| Method                                 | Path                                           | Purpose                                                           |
+| -------------------------------------- | ---------------------------------------------- | ----------------------------------------------------------------- |
+| `dgiiEcf.taxpayer`                     | `GET /dgii-ecf/taxpayer`                       | Resolve which taxpayer the next call uses, and why                |
+| `dgiiEcf.authenticate`                 | `POST /dgii-ecf/authenticate`                  | Warm the DGII token; returns the validity window, never the token |
+| `dgiiEcf.documents`                    | `POST /dgii-ecf/documents`                     | Submit an e-CF, routing on the document's own content             |
+| `dgiiEcf.documents.electronic`         | `POST /dgii-ecf/documents/electronic`          | Submit to the general e-CF reception only                         |
+| `dgiiEcf.documents.summary`            | `POST /dgii-ecf/documents/summary`             | Submit an RFCE summary invoice                                    |
+| `dgiiEcf.documents.commercialApproval` | `POST /dgii-ecf/documents/commercial-approval` | Submit an ACECF                                                   |
+| `dgiiEcf.documents.voidRange`          | `POST /dgii-ecf/documents/void-range`          | Void an e-NCF range (ANECF)                                       |
+| `dgiiEcf.documents.reconcile`          | `POST /dgii-ecf/documents/reconcile`           | Resolve a submission whose outcome is unknown                     |
+| `dgiiEcf.tracks`                       | `GET /dgii-ecf/tracks`                         | Read a track result                                               |
+| `dgiiEcf.inquiries.status`             | `POST /dgii-ecf/inquiries/status`              | Existence check by e-NCF                                          |
+| `dgiiEcf.inquiries.tracks`             | `POST /dgii-ecf/inquiries/tracks`              | Every track DGII holds for an e-NCF                               |
+| `dgiiEcf.inquiries.summary`            | `POST /dgii-ecf/inquiries/summary`             | RFCE inquiry (production only)                                    |
+| `dgiiEcf.directories.customers`        | `GET /dgii-ecf/directories/customers`          | Receiver service directory                                        |
+| `dgiiEcf.directories.all`              | `GET /dgii-ecf/directories/all`                | Every receiver that publishes URLs                                |
+| `dgiiEcf.serviceStatus`                | `GET /dgii-ecf/service-status`                 | DGII service status                                               |
+| `dgiiEcf.maintenanceWindows`           | `GET /dgii-ecf/maintenance-windows`            | DGII maintenance windows                                          |
+| `dgiiEcf.serviceAvailability`          | `GET /dgii-ecf/service-availability`           | Is one environment inside a window                                |
+| `dgiiEcf.submissions`                  | `GET /dgii-ecf/submissions`                    | The submission audit trail                                        |
+
+Every response echoes `taxPayerId`, `organizationId` and `environment`, so a caller can
+always tell which identity acted.
+
+## 🔐 Security posture
+
+- **No certificate in a browser.** Key material is resolved through a server-only
+  callback; `sign: true` signs inside the process that holds it.
+- **No DGII token on the wire.** `authenticate` returns `issuedAt` / `expiresAt`; the
+  bearer token never leaves the server, not even in an error body.
+- **The issuer must match.** A document whose `RNCEmisor` differs from the authorized
+  taxpayer is refused, so a member of organization A cannot submit a document for RNC B.
+- **Replay safe by construction.** The replay key defaults to the SHA-256 of the
+  document, and the pending row is written before transmission.
+- **No fiscal content in the audit table.** Only a hash, the e-NCF, the track id and the
+  operation.
+
+Read [docs/security.md](docs/security.md) for the threat model, including what the
+plugin deliberately does **not** protect against.
+
+## 🧪 Development
+
+Everything runs through [mise](https://mise.jdx.dev) — locally and in CI, with the same
+pinned toolchain.
+
+```bash
+mise install            # provision Node, Bun, pre-commit, gitleaks
+mise run bootstrap      # dependencies + git hooks
+mise run ci             # format check + typecheck + coverage + build + pack checks
+mise tasks              # list every task
+```
+
+| Task                  | What it does                                            |
+| --------------------- | ------------------------------------------------------- |
+| `mise run lint`       | Prettier check + `tsc --noEmit`                         |
+| `mise run test`       | Vitest                                                  |
+| `mise run coverage`   | Vitest with thresholds enforced                         |
+| `mise run build`      | ESM + CJS + declarations                                |
+| `mise run pack-check` | `publint` + `are-the-types-wrong` on the packed tarball |
+| `mise run publish`    | OIDC trusted publish (no token on disk)                 |
+
+## 📚 Documentation
+
+- [Usage guide](docs/usage.md) — modes, endpoints, replay, errors
+- [Architecture](docs/architecture.md) — request lifecycle and data model
+- [Security](docs/security.md) — threat model and guarantees
+- [Decision record](docs/decisions.md) — why the defaults are what they are
+- [Releasing](docs/releasing.md) — trusted publishing, provenance, hotfixes
+- [Contributing](CONTRIBUTING.md) · [Code of Conduct](CODE_OF_CONDUCT.md)
+
+## ⚖️ License
+
+[MIT](LICENSE) © 2026 Deuri Vasquez.
+
+> Not affiliated with the DGII. This is an independent implementation of the publicly
+> documented e-CF specification (Ley 32-23, Decreto 587-24). Always validate against the
+> official
+> [DGII documentation](https://dgii.gov.do/cicloContribuyente/facturacion/comprobantesFiscalesElectronicosE-CF/Paginas/default.aspx).

package/dist/client.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+// src/client.ts
+var dgiiEcfClient = () => ({
+  id: "dgii-ecf",
+  $InferServerPlugin: {}
+});
+
+exports.dgiiEcfClient = dgiiEcfClient;
+//# sourceMappingURL=client.cjs.map
+//# sourceMappingURL=client.cjs.map

package/dist/client.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"names":[],"mappings":";;;AAqBO,IAAM,gBAAgB,OAC1B;AAAA,EACC,EAAA,EAAI,UAAA;AAAA,EACJ,oBAAoB;AACtB,CAAA","file":"client.cjs","sourcesContent":["import type { BetterAuthClientPlugin } from 'better-auth/client';\nimport type { DgiiEcfPlugin } from './plugin.js';\n\n/**\n * Client plugin for {@link import('./plugin.js').dgiiEcf}.\n *\n * It adds no runtime code: Better Auth infers every method from the server\n * plugin's endpoints, so the client cannot drift from the server — a renamed\n * path breaks the build instead of the invoice. Methods are namespaced under\n * `dgiiEcf`:\n *\n * ```ts\n * await authClient.dgiiEcf.documents({ xml, sign: true });\n * await authClient.dgiiEcf.inquiries.status({ ncf, taxPayerId });\n * await authClient.dgiiEcf.serviceStatus();\n * ```\n *\n * The `id` must match the server plugin's `id` so Better Auth can pair them.\n * Importing this module pulls only types, which is what makes it safe to use\n * from a browser bundle.\n */\nexport const dgiiEcfClient = () =>\n  ({\n    id: 'dgii-ecf',\n    $InferServerPlugin: {} as DgiiEcfPlugin,\n  }) satisfies BetterAuthClientPlugin;\n\nexport type DgiiEcfClientPlugin = ReturnType<typeof dgiiEcfClient>;\n"]}

package/dist/client.d.cts

@@ -0,0 +1,31 @@
+import { D as DgiiEcfPlugin } from './plugin-BVYTmUJU.cjs';
+import '@deuriib/dgii-ecf';
+import 'better-auth';
+import 'zod/v4/core';
+import '@better-auth/core/db';
+
+/**
+ * Client plugin for {@link import('./plugin.js').dgiiEcf}.
+ *
+ * It adds no runtime code: Better Auth infers every method from the server
+ * plugin's endpoints, so the client cannot drift from the server — a renamed
+ * path breaks the build instead of the invoice. Methods are namespaced under
+ * `dgiiEcf`:
+ *
+ * ```ts
+ * await authClient.dgiiEcf.documents({ xml, sign: true });
+ * await authClient.dgiiEcf.inquiries.status({ ncf, taxPayerId });
+ * await authClient.dgiiEcf.serviceStatus();
+ * ```
+ *
+ * The `id` must match the server plugin's `id` so Better Auth can pair them.
+ * Importing this module pulls only types, which is what makes it safe to use
+ * from a browser bundle.
+ */
+declare const dgiiEcfClient: () => {
+    id: "dgii-ecf";
+    $InferServerPlugin: DgiiEcfPlugin;
+};
+type DgiiEcfClientPlugin = ReturnType<typeof dgiiEcfClient>;
+
+export { type DgiiEcfClientPlugin, dgiiEcfClient };

package/dist/client.d.ts

@@ -0,0 +1,31 @@
+import { D as DgiiEcfPlugin } from './plugin-BVYTmUJU.js';
+import '@deuriib/dgii-ecf';
+import 'better-auth';
+import 'zod/v4/core';
+import '@better-auth/core/db';
+
+/**
+ * Client plugin for {@link import('./plugin.js').dgiiEcf}.
+ *
+ * It adds no runtime code: Better Auth infers every method from the server
+ * plugin's endpoints, so the client cannot drift from the server — a renamed
+ * path breaks the build instead of the invoice. Methods are namespaced under
+ * `dgiiEcf`:
+ *
+ * ```ts
+ * await authClient.dgiiEcf.documents({ xml, sign: true });
+ * await authClient.dgiiEcf.inquiries.status({ ncf, taxPayerId });
+ * await authClient.dgiiEcf.serviceStatus();
+ * ```
+ *
+ * The `id` must match the server plugin's `id` so Better Auth can pair them.
+ * Importing this module pulls only types, which is what makes it safe to use
+ * from a browser bundle.
+ */
+declare const dgiiEcfClient: () => {
+    id: "dgii-ecf";
+    $InferServerPlugin: DgiiEcfPlugin;
+};
+type DgiiEcfClientPlugin = ReturnType<typeof dgiiEcfClient>;
+
+export { type DgiiEcfClientPlugin, dgiiEcfClient };

package/dist/client.js

@@ -0,0 +1,9 @@
+// src/client.ts
+var dgiiEcfClient = () => ({
+  id: "dgii-ecf",
+  $InferServerPlugin: {}
+});
+
+export { dgiiEcfClient };
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"names":[],"mappings":";AAqBO,IAAM,gBAAgB,OAC1B;AAAA,EACC,EAAA,EAAI,UAAA;AAAA,EACJ,oBAAoB;AACtB,CAAA","file":"client.js","sourcesContent":["import type { BetterAuthClientPlugin } from 'better-auth/client';\nimport type { DgiiEcfPlugin } from './plugin.js';\n\n/**\n * Client plugin for {@link import('./plugin.js').dgiiEcf}.\n *\n * It adds no runtime code: Better Auth infers every method from the server\n * plugin's endpoints, so the client cannot drift from the server — a renamed\n * path breaks the build instead of the invoice. Methods are namespaced under\n * `dgiiEcf`:\n *\n * ```ts\n * await authClient.dgiiEcf.documents({ xml, sign: true });\n * await authClient.dgiiEcf.inquiries.status({ ncf, taxPayerId });\n * await authClient.dgiiEcf.serviceStatus();\n * ```\n *\n * The `id` must match the server plugin's `id` so Better Auth can pair them.\n * Importing this module pulls only types, which is what makes it safe to use\n * from a browser bundle.\n */\nexport const dgiiEcfClient = () =>\n  ({\n    id: 'dgii-ecf',\n    $InferServerPlugin: {} as DgiiEcfPlugin,\n  }) satisfies BetterAuthClientPlugin;\n\nexport type DgiiEcfClientPlugin = ReturnType<typeof dgiiEcfClient>;\n"]}