@ssddo/ecf-sdk 0.1.0

package/README.md

@@ -0,0 +1,244 @@
+# @ssddo/ecf-sdk
+
+SDK de TypeScript para la API de ECF DGII (comprobantes fiscales electrónicos de República Dominicana).
+
+Construido con [openapi-typescript](https://github.com/openapi-ts/openapi-typescript) y [openapi-fetch](https://github.com/openapi-ts/openapi-typescript/tree/main/packages/openapi-fetch) para acceso a la API completamente tipado.
+
+## Instalación
+
+```bash
+npm install @ssddo/ecf-sdk
+```
+
+## Inicio rápido
+
+```typescript
+import { EcfClient } from '@ssddo/ecf-sdk';
+
+const client = new EcfClient({
+  apiKey: 'tu-token-jwt',
+  environment: 'test', // 'test' | 'cert' | 'prod'
+});
+
+// Enviar un ECF y esperar a que termine de procesarse
+const result = await client.sendEcf({
+  Encabezado: {
+    IdDoc: {
+      ENCF: "E310000051630",
+      TipoeCF: "FacturaDeCreditoFiscalElectronica",
+      TipoPago: "Contado",
+      TipoIngresos: "01",
+      TablaFormasPago: [
+        { FormaPago: "Efectivo", MontoPago: 1015.25 },
+      ],
+      IndicadorMontoGravado: "ConITBISIncluido",
+      FechaVencimientoSecuencia: "2028-12-31T00:00:00",
+    },
+    Emisor: {
+      RNCEmisor: "131460941",
+      FechaEmision: "2026-01-10",
+      DireccionEmisor: "AVE. ISABEL AGUIAR NO. 269, ZONA INDUSTRIAL DE HERRERA",
+      RazonSocialEmisor: "DOCUMENTOS ELECTRONICOS DE 02",
+    },
+    Totales: {
+      ITBIS1: 18,
+      MontoGravadoI1: 762.71,
+      MontoGravadoTotal: 762.71,
+      TotalITBIS1: 137.29,
+      TotalITBIS: 137.29,
+      MontoNoFacturable: 100.0,
+      ImpuestosAdicionales: [
+        {
+          TipoImpuesto: "002",
+          TasaImpuestoAdicional: 2,
+          OtrosImpuestosAdicionales: 15.25,
+        },
+      ],
+      MontoImpuestoAdicional: 15.25,
+      MontoTotal: 1015.25,
+      MontoPeriodo: 1015.25,
+    },
+    Version: "Version1_0",
+    Comprador: {
+      RNCComprador: "131880681",
+      RazonSocialComprador: "DOCUMENTOS ELECTRONICOS DE 03",
+    },
+  },
+  DetallesItems: [
+    {
+      MontoItem: 1016.95,
+      NombreItem: "Iphone 18 Pro max",
+      NumeroLinea: 1,
+      CantidadItem: 1,
+      UnidadMedida: "Unidad",
+      PrecioUnitarioItem: 1016.95,
+      IndicadorFacturacion: "ITBIS1_18Percent",
+      IndicadorBienoServicio: "Bien",
+      TablaImpuestoAdicional: [{ TipoImpuesto: "002" }],
+    },
+    {
+      MontoItem: 100.0,
+      NombreItem: "Costo de Envío",
+      NumeroLinea: 2,
+      CantidadItem: 1,
+      UnidadMedida: "Unidad",
+      PrecioUnitarioItem: 100.0,
+      IndicadorFacturacion: "NoFacturable_18Percent",
+      IndicadorBienoServicio: "Servicio",
+    },
+  ],
+  DescuentosORecargos: [
+    {
+      TipoValor: "$",
+      TipoAjuste: "D",
+      NumeroLinea: 1,
+      MontoDescuentooRecargo: 84.75,
+      DescripcionDescuentooRecargo: "Descuento",
+      IndicadorFacturacionDescuentooRecargo: "ITBIS1_18Percent",
+    },
+  ],
+});
+
+console.log(result.progress); // 'Finished'
+console.log(result.encf);
+```
+
+## Configuración de entorno
+
+```typescript
+// Usando un entorno específico
+const client = new EcfClient({
+  apiKey: 'tu-token-jwt',
+  environment: 'prod',
+});
+
+// Usando una URL base personalizada (sobreescribe el entorno)
+const client = new EcfClient({
+  apiKey: 'tu-token-jwt',
+  baseUrl: 'https://api-personalizada.ejemplo.com',
+});
+```
+
+### URLs de entorno
+
+| Entorno | URL |
+|---------|-----|
+| `test` | `https://api.test.ecfx.ssd.com.do` |
+| `cert` | `https://api.cert.ecfx.ssd.com.do` |
+| `prod` | `https://api.prod.ecfx.ssd.com.do` |
+
+## Opciones de polling
+
+El método `sendEcf` hace polling hasta que el ECF sea procesado. Puedes personalizar el comportamiento:
+
+```typescript
+const result = await client.sendEcf(ecf, {
+  initialDelay: 1000,      // Iniciar polling después de 1s (por defecto)
+  maxDelay: 30000,          // Delay máximo entre polls (por defecto)
+  maxRetries: 60,           // Máximo de intentos de poll (por defecto)
+  backoffMultiplier: 2,     // Multiplicador de backoff exponencial (por defecto)
+  timeout: 120000,          // Timeout total en ms
+  signal: abortController.signal, // AbortSignal para cancelación
+});
+```
+
+## Arquitectura Backend / Frontend
+
+En la mayoría de aplicaciones, el backend maneja la lógica de negocio (validación, almacenamiento, conversión) y envía el ECF. El frontend obtiene un token de solo lectura para consultar el estado directamente:
+
+```typescript
+// Backend: tu endpoint de facturas
+const ecfClient = new EcfClient({
+  apiKey: process.env.ECF_BACKEND_TOKEN,
+  environment: 'prod',
+});
+
+app.post('/api/v1/invoices', async (req, res) => {
+  // 1. Validar y guardar tu factura interna
+  const invoice = await validateAndSave(req.body);
+  // 2. Convertir a formato ECF
+  const ecf = convertToEcf(invoice);
+  // 3. Enviar a ECF SSD
+  const { data } = await ecfClient.raw.POST('/ecf/31', { body: ecf });
+  await updateInvoice(invoice.id, { messageId: data.messageId });
+  res.json({ id: invoice.id, messageId: data.messageId });
+});
+
+// Endpoint separado: generar token de solo lectura para el frontend
+app.get('/api/v1/ecf-token', async (req, res) => {
+  const { data } = await ecfClient.createApiKey({ rnc: tenant.rnc });
+  res.json({ token: data.token });
+});
+```
+
+El frontend almacena el token de forma segura, lo renueva ante `401 Unauthorized` o expiración, y consulta ECF SSD directamente. Consulta el [README principal](../README.md#arquitectura-backend--frontend) para el diagrama completo y ejemplo con React.
+
+> **`sendEcf`** envuelve envío + polling en una sola llamada. Ideal para scripts o backends simples sin frontend.
+
+## Acceso directo al cliente
+
+Para acceso directo a todos los endpoints de la API con tipado completo:
+
+```typescript
+// Operaciones de empresa
+const { data } = await client.raw.GET('/company', {
+  params: { query: { Page: 1, Limit: 10 } },
+});
+
+// Consultar estado de ECF
+const { data } = await client.raw.GET('/ecf/{rnc}/{encf}', {
+  params: { path: { rnc: '123456789', encf: 'E320000000001' } },
+});
+
+// Operaciones DGII
+const { data } = await client.raw.GET('/dgii/{rnc}/consultaresultado/estado', {
+  params: { path: { rnc: '123456789' }, query: { trackId: 'abc123' } },
+});
+```
+
+## Métodos de conveniencia
+
+```typescript
+// Empresa
+await client.getCompanies({ Page: 1, Limit: 10 });
+await client.getCompanyByRnc('123456789');
+await client.upsertCompany({ /* ... */ });
+await client.deleteCompany('123456789');
+
+// Certificados
+await client.getCertificate('123456789');
+
+// Consultas ECF
+await client.queryEcf('123456789', 'E320000000001');
+await client.searchEcfs('123456789');
+await client.searchAllEcfs();
+await client.getEcfById('123456789', 'message-uuid');
+
+// Aprobación comercial
+await client.aprobacionComercial('123456789', 'E320000000001', { /* ... */ });
+
+// Anulación rangos
+await client.anulacionRangos('123456789', { /* ... */ });
+await client.listAnulaciones();
+
+// Recepción
+await client.searchEcfReceptionRequests();
+await client.getEcfReceptionRequest('123456789', 'message-uuid');
+
+// DGII
+await client.consultaResultado('123456789', { trackId: 'abc' });
+await client.consultaTimbre('123456789', { /* ... */ });
+await client.estatusServicios('123456789');
+
+// API Keys
+await client.createApiKey({ rnc: '123456789' });
+```
+
+## Compatibilidad
+
+Este SDK usa la API estándar `fetch` y funciona con:
+
+- Node.js 18+
+- Deno
+- Bun
+- Navegadores modernos

package/dist/index.cjs

@@ -0,0 +1,463 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EcfClient: () => EcfClient,
+  EcfError: () => EcfError,
+  EcfFrontendClient: () => EcfFrontendClient,
+  PollingMaxRetriesError: () => PollingMaxRetriesError,
+  PollingTimeoutError: () => PollingTimeoutError,
+  createFrontendClient: () => createFrontendClient,
+  pollUntilComplete: () => pollUntilComplete
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+
+// src/polling.ts
+var PollingTimeoutError = class extends Error {
+  constructor(message = "Polling timed out") {
+    super(message);
+    this.name = "PollingTimeoutError";
+  }
+};
+var PollingMaxRetriesError = class extends Error {
+  constructor(retries) {
+    super(`Polling exceeded maximum retries (${retries})`);
+    this.name = "PollingMaxRetriesError";
+  }
+};
+async function pollUntilComplete(fn, isComplete, options) {
+  const {
+    initialDelay = 1e3,
+    maxDelay = 3e4,
+    maxRetries = 60,
+    backoffMultiplier = 2,
+    timeout,
+    signal
+  } = options ?? {};
+  const startTime = Date.now();
+  let delay = initialDelay;
+  let retries = 0;
+  while (true) {
+    if (signal?.aborted) {
+      throw new DOMException("Polling was aborted", "AbortError");
+    }
+    const result = await fn();
+    if (isComplete(result)) {
+      return result;
+    }
+    retries++;
+    if (retries >= maxRetries) {
+      throw new PollingMaxRetriesError(maxRetries);
+    }
+    if (timeout !== void 0 && Date.now() - startTime >= timeout) {
+      throw new PollingTimeoutError();
+    }
+    await sleep(delay, signal);
+    delay = Math.min(delay * backoffMultiplier, maxDelay);
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Polling was aborted", "AbortError"));
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new DOMException("Polling was aborted", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/client.ts
+var ENVIRONMENT_URLS = {
+  test: "https://api.test.ecfx.ssd.com.do",
+  cert: "https://api.cert.ecfx.ssd.com.do",
+  prod: "https://api.prod.ecfx.ssd.com.do"
+};
+var ECF_TYPE_ROUTE_MAP = {
+  FacturaDeCreditoFiscalElectronica: "31",
+  FacturaDeConsumoElectronica: "32",
+  NotaDeDebitoElectronica: "33",
+  NotaDeCreditoElectronica: "34",
+  ComprasElectronico: "41",
+  GastosMenoresElectronico: "43",
+  RegimenesEspecialesElectronico: "44",
+  GubernamentalElectronico: "45",
+  ComprobanteDeExportacionesElectronico: "46",
+  ComprobanteParaPagosAlExteriorElectronico: "47"
+};
+var EcfError = class extends Error {
+  response;
+  constructor(message, response) {
+    super(message);
+    this.name = "EcfError";
+    this.response = response;
+  }
+};
+var EcfClient = class {
+  /** The underlying openapi-fetch client for direct endpoint access. */
+  raw;
+  constructor(config) {
+    const baseUrl = config.baseUrl ?? ENVIRONMENT_URLS[config.environment ?? "test"];
+    const authMiddleware = {
+      async onRequest({ request }) {
+        request.headers.set("Authorization", `Bearer ${config.apiKey}`);
+        return request;
+      }
+    };
+    this.raw = (0, import_openapi_fetch.default)({ baseUrl });
+    this.raw.use(authMiddleware);
+  }
+  // ---------------------------------------------------------------------------
+  // ECF send + poll
+  // ---------------------------------------------------------------------------
+  /**
+   * Send an ECF and poll until processing completes.
+   *
+   * Determines the correct endpoint from `ecf.encabezado.idDoc.tipoeCF`,
+   * posts the ECF, then polls until `progress` is `Finished` or `Error`.
+   */
+  async sendEcf(ecf, pollingOptions) {
+    const tipoeCF = ecf.encabezado?.idDoc?.tipoeCF;
+    if (!tipoeCF) {
+      throw new Error("ECF must have encabezado.idDoc.tipoeCF");
+    }
+    const route = ECF_TYPE_ROUTE_MAP[tipoeCF];
+    if (!route) {
+      throw new Error(`Unknown tipoeCF: ${tipoeCF}`);
+    }
+    const rnc = ecf.encabezado?.emisor?.rncEmisor;
+    if (!rnc) {
+      throw new Error("ECF must have encabezado.emisor.rncEmisor");
+    }
+    const encf = ecf.encabezado?.idDoc?.encf;
+    if (!encf) {
+      throw new Error("ECF must have encabezado.idDoc.encf");
+    }
+    const response = await this.postEcf(route, ecf);
+    const result = await pollUntilComplete(
+      async () => {
+        const { data: queryData, error: queryError } = await this.raw.GET("/ecf/{rnc}/{encf}", {
+          params: { path: { rnc, encf } }
+        });
+        if (queryError) {
+          throw new Error(`Failed to query ECF status: ${JSON.stringify(queryError)}`);
+        }
+        const results = queryData;
+        const match = results.find((r) => r.messageId === response.messageId) ?? results[0];
+        if (!match) {
+          throw new Error("No ECF response found for the given rnc/encf");
+        }
+        return match;
+      },
+      (r) => r.progress === "Finished" || r.progress === "Error",
+      pollingOptions
+    );
+    if (result.progress === "Error") {
+      throw new EcfError(
+        result.errors ?? result.mensaje ?? "ECF processing failed",
+        result
+      );
+    }
+    return result;
+  }
+  async postEcf(route, body) {
+    const path = `/ecf/${route}`;
+    const { data, error } = await this.raw.POST(path, { body });
+    if (error) {
+      throw new Error(`Failed to send ECF: ${JSON.stringify(error)}`);
+    }
+    return data;
+  }
+  // ---------------------------------------------------------------------------
+  // Company operations
+  // ---------------------------------------------------------------------------
+  /** List companies with optional filters. */
+  async getCompanies(params) {
+    return this.raw.GET("/company", { params: { query: params } });
+  }
+  /** Get a company by RNC. */
+  async getCompanyByRnc(rnc) {
+    return this.raw.GET("/company/{rnc}", { params: { path: { rnc } } });
+  }
+  /** Create or update a company. */
+  async upsertCompany(body) {
+    return this.raw.PUT("/company", { body });
+  }
+  /** Delete a company by RNC. */
+  async deleteCompany(rnc) {
+    return this.raw.DELETE("/company/{rnc}", { params: { path: { rnc } } });
+  }
+  // ---------------------------------------------------------------------------
+  // Certificate operations
+  // ---------------------------------------------------------------------------
+  /** Get the current certificate for a company. */
+  async getCertificate(rnc) {
+    return this.raw.GET("/company/{rnc}/certificate", { params: { path: { rnc } } });
+  }
+  /** Update a company's certificate. Pass a FormData with 'certificate' file and 'password' field. */
+  async updateCertificate(rnc, body) {
+    const formData = new FormData();
+    formData.append("certificate", body.certificate);
+    formData.append("password", body.password);
+    return this.raw.PUT("/company/{rnc}/certificate", {
+      params: { path: { rnc } },
+      body: formData,
+      bodySerializer: (b) => b
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // ECF query operations
+  // ---------------------------------------------------------------------------
+  /** Query ECFs by RNC and eNCF. */
+  async queryEcf(rnc, encf) {
+    return this.raw.GET("/ecf/{rnc}/{encf}", { params: { path: { rnc, encf } } });
+  }
+  /** Search ECFs for a specific RNC. */
+  async searchEcfs(rnc, params) {
+    return this.raw.GET("/ecf/{rnc}", {
+      params: { path: { rnc }, query: params }
+    });
+  }
+  /** Search all ECFs across all companies. */
+  async searchAllEcfs(params) {
+    return this.raw.GET("/ecf", { params: { query: params } });
+  }
+  /** Get a specific ECF by message ID. */
+  async getEcfById(rnc, id) {
+    return this.raw.GET("/ecf/{rnc}/message/{id}", { params: { path: { rnc, id } } });
+  }
+  // ---------------------------------------------------------------------------
+  // Aprobacion comercial
+  // ---------------------------------------------------------------------------
+  /** Send aprobacion comercial for an ECF. */
+  async aprobacionComercial(rnc, encf, body) {
+    return this.raw.POST("/ecf/aprobacioncomercial/{rnc}/{encf}", {
+      params: { path: { rnc, encf } },
+      body
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Anulacion rangos
+  // ---------------------------------------------------------------------------
+  /** Request range annulment. */
+  async anulacionRangos(rnc, body) {
+    return this.raw.POST("/ecf/anularrango/{rnc}", {
+      params: { path: { rnc } },
+      body
+    });
+  }
+  /** List annulments. */
+  async listAnulaciones(params) {
+    return this.raw.GET("/ecf/anulaciones", { params: { query: params } });
+  }
+  // ---------------------------------------------------------------------------
+  // Firmar semilla
+  // ---------------------------------------------------------------------------
+  /** Sign a seed for a company. */
+  async firmarSemilla(rnc, body) {
+    const formData = new FormData();
+    formData.append("xml", body.xml);
+    return this.raw.POST("/ecf/FirmarSemilla/{rnc}", {
+      params: { path: { rnc } },
+      body: formData,
+      bodySerializer: (b) => b
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Recepcion operations
+  // ---------------------------------------------------------------------------
+  /** Search ECF reception requests. */
+  async searchEcfReceptionRequests(params) {
+    return this.raw.GET("/recepcion/ecf", { params: { query: params } });
+  }
+  /** Search ACECF reception requests. */
+  async searchAcecfReceptionRequests(params) {
+    return this.raw.GET("/recepcion/acecf", { params: { query: params } });
+  }
+  /** Search ECF reception requests by RNC. */
+  async searchEcfReceptionRequestsByRnc(rnc, params) {
+    return this.raw.GET("/recepcion/{rnc}/ecf", {
+      params: { path: { rnc }, query: params }
+    });
+  }
+  /** Get a specific ECF reception request. */
+  async getEcfReceptionRequest(rnc, messageId) {
+    return this.raw.GET("/recepcion/{rnc}/ecf/{messageId}", {
+      params: { path: { rnc, messageId } }
+    });
+  }
+  /** Search ACECF reception requests by RNC. */
+  async searchAcecfReceptionRequestsByRnc(rnc, params) {
+    return this.raw.GET("/recepcion/{rnc}/acecf", {
+      params: { path: { rnc }, query: params }
+    });
+  }
+  /** Get a specific ACECF reception request. */
+  async getAcecfReceptionRequest(rnc, messageId) {
+    return this.raw.GET("/recepcion/{rnc}/acecf/{messageId}", {
+      params: { path: { rnc, messageId } }
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // DGII operations
+  // ---------------------------------------------------------------------------
+  /** Consulta directorio - listado. */
+  async consultaDirectorioListado(rnc) {
+    return this.raw.GET("/dgii/{rnc}/consultadirectorio/listado", {
+      params: { path: { rnc } }
+    });
+  }
+  /** Consulta directorio - obtener directorio por RNC. */
+  async consultaDirectorioPorRnc(rnc, query) {
+    return this.raw.GET("/dgii/{rnc}/consultadirectorio/obtener-directorio-por-rnc", {
+      params: { path: { rnc }, query }
+    });
+  }
+  /** Consulta estado. */
+  async consultaEstado(rnc, query) {
+    return this.raw.GET("/dgii/{rnc}/consultaestado/estado", {
+      params: { path: { rnc }, query }
+    });
+  }
+  /** Consulta resultado. */
+  async consultaResultado(rnc, query) {
+    return this.raw.GET("/dgii/{rnc}/consultaresultado/estado", {
+      params: { path: { rnc }, query }
+    });
+  }
+  /** Consulta RFCE. */
+  async consultaRFCE(rnc, query) {
+    return this.raw.GET("/dgii/{rnc}/consultarfce/consulta", {
+      params: { path: { rnc }, query }
+    });
+  }
+  /** Consulta timbre. */
+  async consultaTimbre(rnc, query) {
+    return this.raw.GET("/dgii/{rnc}/consultatimbre", {
+      params: { path: { rnc }, query }
+    });
+  }
+  /** Consulta timbre FC. */
+  async consultaTimbreFC(rnc, query) {
+    return this.raw.GET("/dgii/{rnc}/consultatimbrefc", {
+      params: { path: { rnc }, query }
+    });
+  }
+  /** Consulta track IDs. */
+  async consultaTrackId(rnc, query) {
+    return this.raw.GET("/dgii/{rnc}/consultatrackids/consulta", {
+      params: { path: { rnc }, query }
+    });
+  }
+  /** Estatus servicios - obtener estatus. */
+  async estatusServicios(rnc) {
+    return this.raw.GET("/dgii/{rnc}/estatusservicios/obtener-estatus", {
+      params: { path: { rnc } }
+    });
+  }
+  /** Estatus servicios - obtener ventanas de mantenimiento. */
+  async ventanasMantenimiento(rnc) {
+    return this.raw.GET("/dgii/{rnc}/estatusservicios/obtener-ventanas-mantenimiento", {
+      params: { path: { rnc } }
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // ApiKey operations
+  // ---------------------------------------------------------------------------
+  /** Create a new API key. */
+  async createApiKey(body) {
+    return this.raw.POST("/apiKey", { body });
+  }
+};
+var EcfFrontendClient = class {
+  /** The underlying openapi-fetch client for direct endpoint access. */
+  raw;
+  constructor(config) {
+    const baseUrl = config.baseUrl ?? ENVIRONMENT_URLS[config.environment ?? "test"];
+    const authMiddleware = {
+      async onRequest({ request }) {
+        request.headers.set("Authorization", `Bearer ${config.apiKey}`);
+        return request;
+      }
+    };
+    this.raw = (0, import_openapi_fetch.default)({ baseUrl });
+    this.raw.use(authMiddleware);
+  }
+  /** Query ECFs by RNC and eNCF. */
+  async queryEcf(rnc, encf) {
+    return this.raw.GET("/ecf/{rnc}/{encf}", { params: { path: { rnc, encf } } });
+  }
+  /** Search ECFs for a specific RNC. */
+  async searchEcfs(rnc, params) {
+    return this.raw.GET("/ecf/{rnc}", {
+      params: { path: { rnc }, query: params }
+    });
+  }
+  /** Search all ECFs across all companies. */
+  async searchAllEcfs(params) {
+    return this.raw.GET("/ecf", { params: { query: params } });
+  }
+  /** Get a specific ECF by message ID. */
+  async getEcfById(rnc, id) {
+    return this.raw.GET("/ecf/{rnc}/message/{id}", { params: { path: { rnc, id } } });
+  }
+  /** List companies with optional filters. */
+  async getCompanies(params) {
+    return this.raw.GET("/company", { params: { query: params } });
+  }
+  /** Get a company by RNC. */
+  async getCompanyByRnc(rnc) {
+    return this.raw.GET("/company/{rnc}", { params: { path: { rnc } } });
+  }
+};
+function createFrontendClient(config) {
+  return new EcfFrontendClient(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EcfClient,
+  EcfError,
+  EcfFrontendClient,
+  PollingMaxRetriesError,
+  PollingTimeoutError,
+  createFrontendClient,
+  pollUntilComplete
+});