@setup-automatizado/sicredi-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1495 @@
+'use strict';
+
+var https = require('https');
+var fs = require('fs');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors/base.ts
+exports.SicrediError = void 0;
+var init_base = __esm({
+  "src/errors/base.ts"() {
+    exports.SicrediError = class extends Error {
+      code;
+      hint;
+      constructor(message, code, hint) {
+        super(message);
+        this.name = "SicrediError";
+        this.code = code;
+        this.hint = hint;
+        Object.setPrototypeOf(this, new.target.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/connection-error.ts
+exports.SicrediConnectionError = void 0;
+var init_connection_error = __esm({
+  "src/errors/connection-error.ts"() {
+    init_base();
+    exports.SicrediConnectionError = class _SicrediConnectionError extends exports.SicrediError {
+      cause;
+      constructor(message, cause, hint) {
+        super(message, "CONNECTION_ERROR", hint);
+        this.name = "SicrediConnectionError";
+        this.cause = cause;
+        Object.setPrototypeOf(this, new.target.prototype);
+      }
+      static timeout(ms) {
+        return new _SicrediConnectionError(`Request timed out after ${ms}ms`);
+      }
+      static refused(host) {
+        return new _SicrediConnectionError(`Connection refused to host: ${host}`);
+      }
+      static tlsFailure(detail) {
+        return new _SicrediConnectionError(
+          `TLS/mTLS handshake failed: ${detail}`,
+          void 0,
+          "Verify that your mTLS certificates are valid, not expired, and correctly configured. Ensure the CA chain is complete."
+        );
+      }
+    };
+  }
+});
+
+// src/core/http-client-bun.ts
+var http_client_bun_exports = {};
+__export(http_client_bun_exports, {
+  BunHttpClient: () => BunHttpClient
+});
+var BunHttpClient;
+var init_http_client_bun = __esm({
+  "src/core/http-client-bun.ts"() {
+    init_connection_error();
+    BunHttpClient = class {
+      tlsOptions;
+      defaultTimeout;
+      debug;
+      constructor(config) {
+        this.defaultTimeout = config.timeout;
+        this.debug = config.debug;
+        this.tlsOptions = {
+          cert: config.certificates.cert,
+          key: config.certificates.key,
+          ca: config.certificates.ca,
+          passphrase: config.certificates.passphrase
+        };
+      }
+      async request(options) {
+        const timeout = options.timeout ?? this.defaultTimeout;
+        if (this.debug) {
+          const url = new URL(options.url);
+          console.debug(`[sicredi-sdk] ${options.method} ${url.pathname}`);
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          const response = await fetch(options.url, {
+            method: options.method,
+            headers: options.headers,
+            body: options.body,
+            signal: controller.signal,
+            // @ts-expect-error Bun-specific TLS options
+            tls: this.tlsOptions
+          });
+          const body = await response.text();
+          const headers = {};
+          response.headers.forEach((value, key) => {
+            headers[key] = value;
+          });
+          return {
+            status: response.status,
+            headers,
+            body
+          };
+        } catch (error) {
+          if (error instanceof DOMException && error.name === "AbortError") {
+            throw exports.SicrediConnectionError.timeout(timeout);
+          }
+          if (error instanceof Error) {
+            const msg = error.message.toLowerCase();
+            if (msg.includes("econnrefused")) {
+              throw exports.SicrediConnectionError.refused(new URL(options.url).hostname);
+            }
+            if (msg.includes("tls") || msg.includes("ssl") || msg.includes("certificate")) {
+              throw exports.SicrediConnectionError.tlsFailure(error.message);
+            }
+            throw new exports.SicrediConnectionError(error.message, error);
+          }
+          throw new exports.SicrediConnectionError("Unknown connection error");
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+    };
+  }
+});
+
+// src/core/http-client-node.ts
+var http_client_node_exports = {};
+__export(http_client_node_exports, {
+  NodeHttpClient: () => NodeHttpClient
+});
+var NodeHttpClient;
+var init_http_client_node = __esm({
+  "src/core/http-client-node.ts"() {
+    init_connection_error();
+    NodeHttpClient = class {
+      agent;
+      defaultTimeout;
+      debug;
+      constructor(config) {
+        this.defaultTimeout = config.timeout;
+        this.debug = config.debug;
+        this.agent = new https.Agent({
+          cert: config.certificates.cert,
+          key: config.certificates.key,
+          ca: config.certificates.ca,
+          passphrase: config.certificates.passphrase,
+          keepAlive: true,
+          maxSockets: 10
+        });
+      }
+      request(options) {
+        return new Promise((resolve, reject) => {
+          const url = new URL(options.url);
+          const timeout = options.timeout ?? this.defaultTimeout;
+          if (this.debug) {
+            console.debug(`[sicredi-sdk] ${options.method} ${url.pathname}`);
+          }
+          const req = https.request(
+            {
+              hostname: url.hostname,
+              port: url.port || 443,
+              path: url.pathname + url.search,
+              method: options.method,
+              headers: options.headers,
+              agent: this.agent,
+              timeout
+            },
+            (res) => {
+              const chunks = [];
+              res.on("data", (chunk) => chunks.push(chunk));
+              res.on("end", () => {
+                const body = Buffer.concat(chunks).toString("utf-8");
+                const headers = {};
+                for (const [key, value] of Object.entries(res.headers)) {
+                  if (typeof value === "string") {
+                    headers[key] = value;
+                  } else if (Array.isArray(value)) {
+                    headers[key] = value.join(", ");
+                  }
+                }
+                resolve({
+                  status: res.statusCode ?? 0,
+                  headers,
+                  body
+                });
+              });
+              res.on("error", (err) => {
+                reject(new exports.SicrediConnectionError(err.message, err));
+              });
+            }
+          );
+          req.on("timeout", () => {
+            req.destroy();
+            reject(exports.SicrediConnectionError.timeout(timeout));
+          });
+          req.on("error", (err) => {
+            const msg = err.message.toLowerCase();
+            if (msg.includes("econnrefused")) {
+              reject(exports.SicrediConnectionError.refused(url.hostname));
+            } else if (msg.includes("ssl") || msg.includes("tls") || msg.includes("certificate")) {
+              reject(exports.SicrediConnectionError.tlsFailure(err.message));
+            } else {
+              reject(new exports.SicrediConnectionError(err.message, err));
+            }
+          });
+          if (options.body) {
+            req.write(options.body);
+          }
+          req.end();
+        });
+      }
+    };
+  }
+});
+
+// src/errors/api-error.ts
+init_base();
+var SicrediApiError = class _SicrediApiError extends exports.SicrediError {
+  statusCode;
+  type;
+  title;
+  detail;
+  violacoes;
+  constructor(statusCode, body) {
+    const message = body.detail ? `${body.title}: ${body.detail}` : body.title;
+    super(message, "API_ERROR");
+    this.name = "SicrediApiError";
+    this.statusCode = statusCode;
+    this.type = body.type;
+    this.title = body.title;
+    this.detail = body.detail;
+    this.violacoes = body.violacoes;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static fromResponse(statusCode, body) {
+    if (typeof body === "object" && body !== null && "title" in body && typeof body.title === "string") {
+      return new _SicrediApiError(statusCode, body);
+    }
+    const fallback = {
+      title: "Unknown API Error",
+      status: statusCode,
+      detail: typeof body === "string" ? body : JSON.stringify(body)
+    };
+    return new _SicrediApiError(statusCode, fallback);
+  }
+};
+
+// src/errors/auth-error.ts
+init_base();
+var SicrediAuthError = class _SicrediAuthError extends exports.SicrediError {
+  constructor(message, hint) {
+    super(message, "AUTH_ERROR", hint);
+    this.name = "SicrediAuthError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static invalidCredentials() {
+    return new _SicrediAuthError(
+      "Invalid credentials",
+      "Check that your clientId and clientSecret are correct and have not been revoked."
+    );
+  }
+  static tokenExpired() {
+    return new _SicrediAuthError(
+      "Access token has expired",
+      "The token will be automatically refreshed on the next request. If this persists, re-authenticate."
+    );
+  }
+  static insufficientScope(required) {
+    return new _SicrediAuthError(
+      "Insufficient scope for this operation",
+      `This operation requires the following scope: ${required}. Ensure your credentials are provisioned with the necessary permissions.`
+    );
+  }
+};
+
+// src/utils/constants.ts
+var SICREDI_URLS = {
+  production: "https://api-pix.sicredi.com.br",
+  sandbox: "https://api-pix-h.sicredi.com.br"
+};
+var SICREDI_ISPB = "01181521";
+var OAUTH_SCOPES = "cob.write cob.read cobv.write cobv.read pix.read webhook.read webhook.write lotecobv.write lotecobv.read";
+var API_VERSIONS = {
+  cob: {
+    create: "/api/v2/cob",
+    get: "/api/v3/cob",
+    // NOTE: GET uses v3!
+    update: "/api/v2/cob",
+    list: "/api/v2/cob"
+  },
+  cobv: {
+    create: "/api/v2/cobv",
+    get: "/api/v2/cobv",
+    update: "/api/v2/cobv",
+    list: "/api/v2/cobv"
+  },
+  pix: {
+    base: "/api/v2/pix"
+  },
+  lotecobv: {
+    base: "/api/v2/lotecobv"
+  },
+  loc: {
+    base: "/api/v2/loc"
+  },
+  webhook: {
+    base: "/api/v2/webhook"
+  }
+};
+var TOKEN_ENDPOINT = "/oauth/token";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+
+// src/core/auth-manager.ts
+var AuthManager = class {
+  constructor(clientId, clientSecret, baseUrl, httpClient) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.baseUrl = baseUrl;
+    this.httpClient = httpClient;
+  }
+  cachedToken = null;
+  refreshPromise = null;
+  async getAccessToken() {
+    if (this.cachedToken && !this.isTokenExpiringSoon()) {
+      return this.cachedToken.accessToken;
+    }
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.refreshToken();
+    try {
+      return await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  invalidateToken() {
+    this.cachedToken = null;
+  }
+  isTokenExpiringSoon() {
+    if (!this.cachedToken) return true;
+    return Date.now() >= this.cachedToken.expiresAt - TOKEN_REFRESH_BUFFER_MS;
+  }
+  async refreshToken() {
+    const credentials = btoa(`${this.clientId}:${this.clientSecret}`);
+    const scopes = encodeURIComponent(OAUTH_SCOPES);
+    const url = `${this.baseUrl}${TOKEN_ENDPOINT}?grant_type=client_credentials&scope=${scopes}`;
+    const response = await this.httpClient.request({
+      method: "POST",
+      url,
+      headers: {
+        Authorization: `Basic ${credentials}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    if (response.status !== 200) {
+      let body;
+      try {
+        body = JSON.parse(response.body);
+      } catch {
+      }
+      if (response.status === 401 || response.status === 403) {
+        throw SicrediAuthError.invalidCredentials();
+      }
+      throw SicrediApiError.fromResponse(response.status, body);
+    }
+    let tokenData;
+    try {
+      tokenData = JSON.parse(response.body);
+    } catch {
+      throw new SicrediAuthError("Invalid token response from server");
+    }
+    this.cachedToken = {
+      accessToken: tokenData.access_token,
+      expiresAt: Date.now() + tokenData.expires_in * 1e3,
+      scope: tokenData.scope
+    };
+    return this.cachedToken.accessToken;
+  }
+};
+
+// src/errors/certificate-error.ts
+init_base();
+var SicrediCertificateError = class _SicrediCertificateError extends exports.SicrediError {
+  constructor(message, hint) {
+    super(message, "CERTIFICATE_ERROR", hint);
+    this.name = "SicrediCertificateError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static notFound(path) {
+    return new _SicrediCertificateError(
+      `Certificate file not found: ${path}`,
+      "Verify that the file exists at the specified path and that the process has read permissions."
+    );
+  }
+  static invalidFormat(detail) {
+    return new _SicrediCertificateError(
+      `Invalid certificate format: ${detail}`,
+      "Certificate appears to be in DER format. Convert to PEM using: openssl x509 -inform der -in cert.cer -out cert.pem"
+    );
+  }
+  static keyMismatch() {
+    return new _SicrediCertificateError(
+      "Private key does not match the certificate",
+      "Ensure the private key corresponds to the public key in the certificate. Verify with: openssl x509 -noout -modulus -in cert.pem | openssl md5 && openssl rsa -noout -modulus -in key.pem | openssl md5"
+    );
+  }
+  static expired() {
+    return new _SicrediCertificateError(
+      "Certificate has expired",
+      "Request a new certificate from Sicredi and update your configuration."
+    );
+  }
+};
+
+// src/core/certificate-manager.ts
+var PEM_HEADER_PATTERN = /-----BEGIN [A-Z\s]+-----/;
+var DER_SIGNATURE = [48, 130];
+function isPemContent(content) {
+  return PEM_HEADER_PATTERN.test(content);
+}
+function isDerContent(buffer) {
+  return buffer.length > 2 && buffer[0] === DER_SIGNATURE[0] && buffer[1] === DER_SIGNATURE[1];
+}
+function loadCertificateContent(input, label) {
+  if (isPemContent(input)) {
+    return input;
+  }
+  if (!fs.existsSync(input)) {
+    throw SicrediCertificateError.notFound(input);
+  }
+  const raw = fs.readFileSync(input);
+  const text = raw.toString("utf-8");
+  if (isPemContent(text)) {
+    return text;
+  }
+  if (isDerContent(raw)) {
+    throw SicrediCertificateError.invalidFormat(
+      `${label} at "${input}" appears to be in DER format`
+    );
+  }
+  return raw;
+}
+var CertificateManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  resolved = null;
+  resolve() {
+    if (this.resolved) {
+      return this.resolved;
+    }
+    const cert = loadCertificateContent(this.options.cert, "Certificate");
+    const key = loadCertificateContent(this.options.key, "Private key");
+    const ca = this.options.ca ? loadCertificateContent(this.options.ca, "CA certificate") : void 0;
+    this.resolved = {
+      cert,
+      key,
+      ca,
+      passphrase: this.options.passphrase
+    };
+    return this.resolved;
+  }
+  clear() {
+    this.resolved = null;
+  }
+};
+
+// src/core/http-client.ts
+function isBunRuntime() {
+  return typeof globalThis !== "undefined" && "Bun" in globalThis;
+}
+async function createHttpClient(config) {
+  if (isBunRuntime()) {
+    const { BunHttpClient: BunHttpClient2 } = await Promise.resolve().then(() => (init_http_client_bun(), http_client_bun_exports));
+    return new BunHttpClient2(config);
+  }
+  const { NodeHttpClient: NodeHttpClient2 } = await Promise.resolve().then(() => (init_http_client_node(), http_client_node_exports));
+  return new NodeHttpClient2(config);
+}
+
+// src/errors/validation-error.ts
+init_base();
+var SicrediValidationError = class extends exports.SicrediError {
+  field;
+  constraint;
+  constructor(field, constraint, hint) {
+    super(`Validation failed for field '${field}': ${constraint}`, "VALIDATION_ERROR", hint);
+    this.name = "SicrediValidationError";
+    this.field = field;
+    this.constraint = constraint;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/utils/txid.ts
+var TXID_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var TXID_MIN_LENGTH = 26;
+var TXID_MAX_LENGTH = 35;
+var TXID_PATTERN = /^[a-zA-Z0-9]{26,35}$/;
+function generateTxId(length = 35) {
+  if (length < TXID_MIN_LENGTH || length > TXID_MAX_LENGTH) {
+    throw new Error(`txid length must be between ${TXID_MIN_LENGTH} and ${TXID_MAX_LENGTH}`);
+  }
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += TXID_CHARS[bytes[i] % TXID_CHARS.length];
+  }
+  return result;
+}
+function isValidTxId(txid) {
+  return TXID_PATTERN.test(txid);
+}
+
+// src/core/retry.ts
+init_connection_error();
+var DEFAULT_BASE_DELAY_MS = 500;
+var DEFAULT_MAX_DELAY_MS = 15e3;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+function isRetryableStatusCode(statusCode) {
+  return RETRYABLE_STATUS_CODES.has(statusCode);
+}
+function isRetryableError(error) {
+  if (error instanceof exports.SicrediConnectionError) {
+    return true;
+  }
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("econnreset") || msg.includes("econnrefused") || msg.includes("etimedout") || msg.includes("socket hang up") || msg.includes("network");
+  }
+  return false;
+}
+function calculateDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponentialDelay = baseDelayMs * 2 ** attempt;
+  const jitter = Math.random() * baseDelayMs;
+  return Math.min(exponentialDelay + jitter, maxDelayMs);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options) {
+  const {
+    maxRetries,
+    baseDelayMs = DEFAULT_BASE_DELAY_MS,
+    maxDelayMs = DEFAULT_MAX_DELAY_MS
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries) {
+        break;
+      }
+      if (!isRetryableError(error)) {
+        break;
+      }
+      const delay = calculateDelay(attempt, baseDelayMs, maxDelayMs);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+
+// src/resources/base.ts
+var BaseResource = class {
+  baseUrl;
+  httpClient;
+  authManager;
+  retryOptions;
+  debug;
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.httpClient = config.httpClient;
+    this.authManager = config.authManager;
+    this.retryOptions = config.retryOptions;
+    this.debug = config.debug;
+  }
+  async request(method, path, body, query) {
+    return withRetry(async () => {
+      const token = await this.authManager.getAccessToken();
+      const url = this.buildUrl(path, query);
+      const response = await this.httpClient.request({
+        method,
+        url,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (response.status === 401 || response.status === 403) {
+        this.authManager.invalidateToken();
+        throw response.status === 401 ? SicrediAuthError.tokenExpired() : SicrediAuthError.insufficientScope("required scope");
+      }
+      if (response.status >= 400) {
+        let parsedBody;
+        try {
+          parsedBody = JSON.parse(response.body);
+        } catch {
+          parsedBody = {
+            title: "Unknown error",
+            status: response.status,
+            detail: response.body
+          };
+        }
+        const error = SicrediApiError.fromResponse(response.status, parsedBody);
+        if (isRetryableStatusCode(response.status)) {
+          throw error;
+        }
+        throw error;
+      }
+      if (response.status === 204 || !response.body) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(response.body);
+      } catch {
+        return response.body;
+      }
+    }, this.retryOptions);
+  }
+  buildUrl(path, query) {
+    const url = new URL(path, this.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+};
+
+// src/resources/cob.ts
+var CobResource = class extends BaseResource {
+  /**
+   * Create a PIX immediate charge with a specific txid.
+   * PUT /api/v2/cob/{txid}
+   */
+  async create(txid, data) {
+    if (!isValidTxId(txid)) {
+      throw new SicrediValidationError("txid", "Must be 26-35 alphanumeric characters");
+    }
+    return this.request("PUT", `${API_VERSIONS.cob.create}/${txid}`, data);
+  }
+  /**
+   * Create a PIX immediate charge with auto-generated txid.
+   * POST /api/v2/cob
+   */
+  async createAuto(data) {
+    return this.request("POST", API_VERSIONS.cob.create, data);
+  }
+  /**
+   * Get a PIX immediate charge by txid.
+   * GET /api/v3/cob/{txid} (note: v3!)
+   */
+  async get(txid, revisao) {
+    if (!isValidTxId(txid)) {
+      throw new SicrediValidationError("txid", "Must be 26-35 alphanumeric characters");
+    }
+    return this.request("GET", `${API_VERSIONS.cob.get}/${txid}`, void 0, {
+      revisao
+    });
+  }
+  /**
+   * Update (patch) a PIX immediate charge.
+   * PATCH /api/v2/cob/{txid}
+   */
+  async update(txid, data) {
+    if (!isValidTxId(txid)) {
+      throw new SicrediValidationError("txid", "Must be 26-35 alphanumeric characters");
+    }
+    return this.request("PATCH", `${API_VERSIONS.cob.update}/${txid}`, data);
+  }
+  /**
+   * Cancel a PIX immediate charge by setting status to REMOVIDA_PELO_USUARIO_RECEBEDOR.
+   * PATCH /api/v2/cob/{txid}
+   */
+  async cancel(txid) {
+    return this.update(txid, { status: "REMOVIDA_PELO_USUARIO_RECEBEDOR" });
+  }
+  /**
+   * List PIX immediate charges with filters.
+   * GET /api/v2/cob
+   */
+  async list(params) {
+    const query = {
+      inicio: params.inicio,
+      fim: params.fim,
+      cpf: params.cpf,
+      cnpj: params.cnpj,
+      locationPresente: params.locationPresente,
+      status: params.status,
+      "paginacao.paginaAtual": params.paginacao?.paginaAtual,
+      "paginacao.itensPorPagina": params.paginacao?.itensPorPagina
+    };
+    return this.request("GET", API_VERSIONS.cob.list, void 0, query);
+  }
+  /**
+   * Generate a txid (helper utility).
+   */
+  generateTxId(length) {
+    return generateTxId(length);
+  }
+};
+
+// src/resources/cobv.ts
+var CobvResource = class extends BaseResource {
+  /**
+   * Create a Boleto Hibrido (PIX with due date) charge.
+   * PUT /api/v2/cobv/{txid}
+   */
+  async create(txid, data) {
+    if (!isValidTxId(txid)) {
+      throw new SicrediValidationError("txid", "Must be 26-35 alphanumeric characters");
+    }
+    return this.request("PUT", `${API_VERSIONS.cobv.create}/${txid}`, data);
+  }
+  /**
+   * Get a Boleto Hibrido charge by txid.
+   * GET /api/v2/cobv/{txid}
+   */
+  async get(txid, revisao) {
+    if (!isValidTxId(txid)) {
+      throw new SicrediValidationError("txid", "Must be 26-35 alphanumeric characters");
+    }
+    return this.request("GET", `${API_VERSIONS.cobv.get}/${txid}`, void 0, {
+      revisao
+    });
+  }
+  /**
+   * Update (patch) a Boleto Hibrido charge.
+   * PATCH /api/v2/cobv/{txid}
+   */
+  async update(txid, data) {
+    if (!isValidTxId(txid)) {
+      throw new SicrediValidationError("txid", "Must be 26-35 alphanumeric characters");
+    }
+    return this.request("PATCH", `${API_VERSIONS.cobv.update}/${txid}`, data);
+  }
+  /**
+   * Cancel a Boleto Hibrido charge.
+   * PATCH /api/v2/cobv/{txid}
+   */
+  async cancel(txid) {
+    return this.update(txid, { status: "REMOVIDA_PELO_USUARIO_RECEBEDOR" });
+  }
+  /**
+   * List Boleto Hibrido charges with filters.
+   * GET /api/v2/cobv
+   */
+  async list(params) {
+    const query = {
+      inicio: params.inicio,
+      fim: params.fim,
+      cpf: params.cpf,
+      cnpj: params.cnpj,
+      locationPresente: params.locationPresente,
+      status: params.status,
+      loteCobVId: params.loteCobVId,
+      "paginacao.paginaAtual": params.paginacao?.paginaAtual,
+      "paginacao.itensPorPagina": params.paginacao?.itensPorPagina
+    };
+    return this.request("GET", API_VERSIONS.cobv.list, void 0, query);
+  }
+};
+
+// src/resources/loc.ts
+var LocResource = class extends BaseResource {
+  /**
+   * Create a payload location.
+   * POST /api/v2/loc
+   */
+  async create(data) {
+    return this.request("POST", API_VERSIONS.loc.base, data);
+  }
+  /**
+   * Get a payload location by ID.
+   * GET /api/v2/loc/{id}
+   */
+  async get(id) {
+    return this.request("GET", `${API_VERSIONS.loc.base}/${id}`);
+  }
+  /**
+   * List payload locations.
+   * GET /api/v2/loc
+   */
+  async list(params) {
+    const query = {
+      inicio: params.inicio,
+      fim: params.fim,
+      tipoCob: params.tipoCob,
+      txIdPresente: params.txIdPresente,
+      "paginacao.paginaAtual": params.paginacao?.paginaAtual,
+      "paginacao.itensPorPagina": params.paginacao?.itensPorPagina
+    };
+    return this.request("GET", API_VERSIONS.loc.base, void 0, query);
+  }
+  /**
+   * Unlink a charge from a payload location.
+   * DELETE /api/v2/loc/{id}/txid
+   */
+  async unlink(id) {
+    return this.request("DELETE", `${API_VERSIONS.loc.base}/${id}/txid`);
+  }
+};
+
+// src/resources/lotecobv.ts
+var LoteCobvResource = class extends BaseResource {
+  /**
+   * Create or replace a batch of cobv charges.
+   * PUT /api/v2/lotecobv/{id}
+   */
+  async create(id, data) {
+    await this.request("PUT", `${API_VERSIONS.lotecobv.base}/${id}`, data);
+  }
+  /**
+   * Revise specific charges within a batch.
+   * PATCH /api/v2/lotecobv/{id}
+   */
+  async update(id, data) {
+    await this.request("PATCH", `${API_VERSIONS.lotecobv.base}/${id}`, data);
+  }
+  /**
+   * Query a specific batch of cobv charges.
+   * GET /api/v2/lotecobv/{id}
+   */
+  async get(id) {
+    return this.request("GET", `${API_VERSIONS.lotecobv.base}/${id}`);
+  }
+  /**
+   * List batches of cobv charges.
+   * GET /api/v2/lotecobv
+   */
+  async list(params) {
+    const query = {
+      inicio: params.inicio,
+      fim: params.fim,
+      "paginacao.paginaAtual": params.paginacao?.paginaAtual,
+      "paginacao.itensPorPagina": params.paginacao?.itensPorPagina
+    };
+    return this.request("GET", API_VERSIONS.lotecobv.base, void 0, query);
+  }
+};
+
+// src/resources/pix.ts
+var PixResource = class extends BaseResource {
+  /**
+   * Query a received PIX payment by its end-to-end ID.
+   * GET /api/v2/pix/{e2eid}
+   */
+  async get(e2eid) {
+    return this.request("GET", `${API_VERSIONS.pix.base}/${e2eid}`);
+  }
+  /**
+   * List received PIX payments with filters.
+   * GET /api/v2/pix
+   */
+  async list(params) {
+    const query = {
+      inicio: params.inicio,
+      fim: params.fim,
+      txid: params.txid,
+      txIdPresente: params.txIdPresente,
+      devolucaoPresente: params.devolucaoPresente,
+      cpf: params.cpf,
+      cnpj: params.cnpj,
+      "paginacao.paginaAtual": params.paginacao?.paginaAtual,
+      "paginacao.itensPorPagina": params.paginacao?.itensPorPagina
+    };
+    return this.request("GET", API_VERSIONS.pix.base, void 0, query);
+  }
+  /**
+   * Request a refund/return for a received PIX payment.
+   * PUT /api/v2/pix/{e2eid}/devolucao/{id}
+   */
+  async requestReturn(e2eid, id, data) {
+    return this.request(
+      "PUT",
+      `${API_VERSIONS.pix.base}/${e2eid}/devolucao/${id}`,
+      data
+    );
+  }
+  /**
+   * Query the status of a refund/return.
+   * GET /api/v2/pix/{e2eid}/devolucao/{id}
+   */
+  async getReturn(e2eid, id) {
+    return this.request(
+      "GET",
+      `${API_VERSIONS.pix.base}/${e2eid}/devolucao/${id}`
+    );
+  }
+};
+
+// src/resources/webhook.ts
+var WebhookResource = class extends BaseResource {
+  /**
+   * Configure a webhook for a PIX key.
+   * PUT /api/v2/webhook/{chave}
+   */
+  async configure(chave, webhookUrl) {
+    const body = { webhookUrl };
+    await this.request("PUT", `${API_VERSIONS.webhook.base}/${chave}`, body);
+  }
+  /**
+   * Get webhook configuration for a PIX key.
+   * GET /api/v2/webhook/{chave}
+   */
+  async get(chave) {
+    return this.request("GET", `${API_VERSIONS.webhook.base}/${chave}`);
+  }
+  /**
+   * Delete webhook configuration for a PIX key.
+   * DELETE /api/v2/webhook/{chave}
+   */
+  async delete(chave) {
+    await this.request("DELETE", `${API_VERSIONS.webhook.base}/${chave}`);
+  }
+  /**
+   * List all webhook configurations.
+   * GET /api/v2/webhook
+   */
+  async list(params) {
+    const query = {
+      inicio: params.inicio,
+      fim: params.fim,
+      "paginacao.paginaAtual": params.paginacao?.paginaAtual,
+      "paginacao.itensPorPagina": params.paginacao?.itensPorPagina
+    };
+    return this.request("GET", API_VERSIONS.webhook.base, void 0, query);
+  }
+};
+
+// src/client.ts
+var PROXY_PASSTHROUGH = /* @__PURE__ */ new Set(["then", "catch", "finally", "toJSON", "toString", "valueOf"]);
+var Sicredi = class {
+  cob;
+  cobv;
+  pix;
+  lotecobv;
+  loc;
+  webhook;
+  _config;
+  _initPromise = null;
+  _cob = null;
+  _cobv = null;
+  _pix = null;
+  _lotecobv = null;
+  _loc = null;
+  _webhook = null;
+  constructor(config) {
+    this._config = {
+      ...config,
+      environment: config.environment ?? "production",
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+      debug: config.debug ?? false
+    };
+    const self = this;
+    this.cob = new Proxy({}, {
+      get(_target, prop) {
+        if (typeof prop !== "string" || PROXY_PASSTHROUGH.has(prop)) return void 0;
+        return async (...args) => {
+          await self._ensureInit();
+          const method = self._cob[prop];
+          if (typeof method === "function") {
+            return method.apply(self._cob, args);
+          }
+          return method;
+        };
+      }
+    });
+    this.cobv = new Proxy({}, {
+      get(_target, prop) {
+        if (typeof prop !== "string" || PROXY_PASSTHROUGH.has(prop)) return void 0;
+        return async (...args) => {
+          await self._ensureInit();
+          const method = self._cobv[prop];
+          if (typeof method === "function") {
+            return method.apply(self._cobv, args);
+          }
+          return method;
+        };
+      }
+    });
+    this.pix = new Proxy({}, {
+      get(_target, prop) {
+        if (typeof prop !== "string" || PROXY_PASSTHROUGH.has(prop)) return void 0;
+        return async (...args) => {
+          await self._ensureInit();
+          const method = self._pix[prop];
+          if (typeof method === "function") {
+            return method.apply(self._pix, args);
+          }
+          return method;
+        };
+      }
+    });
+    this.lotecobv = new Proxy({}, {
+      get(_target, prop) {
+        if (typeof prop !== "string" || PROXY_PASSTHROUGH.has(prop)) return void 0;
+        return async (...args) => {
+          await self._ensureInit();
+          const method = self._lotecobv[prop];
+          if (typeof method === "function") {
+            return method.apply(self._lotecobv, args);
+          }
+          return method;
+        };
+      }
+    });
+    this.loc = new Proxy({}, {
+      get(_target, prop) {
+        if (typeof prop !== "string" || PROXY_PASSTHROUGH.has(prop)) return void 0;
+        return async (...args) => {
+          await self._ensureInit();
+          const method = self._loc[prop];
+          if (typeof method === "function") {
+            return method.apply(self._loc, args);
+          }
+          return method;
+        };
+      }
+    });
+    this.webhook = new Proxy({}, {
+      get(_target, prop) {
+        if (typeof prop !== "string" || PROXY_PASSTHROUGH.has(prop)) return void 0;
+        return async (...args) => {
+          await self._ensureInit();
+          const method = self._webhook[prop];
+          if (typeof method === "function") {
+            return method.apply(self._webhook, args);
+          }
+          return method;
+        };
+      }
+    });
+  }
+  get baseUrl() {
+    return this._config.baseUrl ?? SICREDI_URLS[this._config.environment];
+  }
+  async _ensureInit() {
+    if (this._cob) return;
+    if (!this._initPromise) {
+      this._initPromise = this._initialize().catch((err) => {
+        this._initPromise = null;
+        throw err;
+      });
+    }
+    await this._initPromise;
+  }
+  async _initialize() {
+    const certManager = new CertificateManager(this._config.certificate);
+    const certificates = certManager.resolve();
+    const httpClient = await createHttpClient({
+      certificates,
+      timeout: this._config.timeout,
+      debug: this._config.debug
+    });
+    const authManager = new AuthManager(
+      this._config.clientId,
+      this._config.clientSecret,
+      this.baseUrl,
+      httpClient
+    );
+    const resourceConfig = {
+      baseUrl: this.baseUrl,
+      httpClient,
+      authManager,
+      retryOptions: { maxRetries: this._config.maxRetries },
+      debug: this._config.debug
+    };
+    this._cob = new CobResource(resourceConfig);
+    this._cobv = new CobvResource(resourceConfig);
+    this._pix = new PixResource(resourceConfig);
+    this._lotecobv = new LoteCobvResource(resourceConfig);
+    this._loc = new LocResource(resourceConfig);
+    this._webhook = new WebhookResource(resourceConfig);
+  }
+};
+
+// src/errors/index.ts
+init_base();
+init_connection_error();
+
+// src/utils/validators.ts
+function isValidCpf(cpf) {
+  const stripped = cpf.replace(/\D/g, "");
+  if (stripped.length !== 11) {
+    return false;
+  }
+  if (/^(\d)\1{10}$/.test(stripped)) {
+    return false;
+  }
+  let sum = 0;
+  for (let i = 0; i < 9; i++) {
+    sum += Number.parseInt(stripped[i], 10) * (10 - i);
+  }
+  let remainder = sum * 10 % 11;
+  if (remainder === 10) remainder = 0;
+  if (remainder !== Number.parseInt(stripped[9], 10)) {
+    return false;
+  }
+  sum = 0;
+  for (let i = 0; i < 10; i++) {
+    sum += Number.parseInt(stripped[i], 10) * (11 - i);
+  }
+  remainder = sum * 10 % 11;
+  if (remainder === 10) remainder = 0;
+  if (remainder !== Number.parseInt(stripped[10], 10)) {
+    return false;
+  }
+  return true;
+}
+function isValidCnpj(cnpj) {
+  const stripped = cnpj.replace(/\D/g, "");
+  if (stripped.length !== 14) {
+    return false;
+  }
+  if (/^(\d)\1{13}$/.test(stripped)) {
+    return false;
+  }
+  const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+  let sum = 0;
+  for (let i = 0; i < 12; i++) {
+    sum += Number.parseInt(stripped[i], 10) * weights1[i];
+  }
+  let remainder = sum % 11;
+  const digit1 = remainder < 2 ? 0 : 11 - remainder;
+  if (digit1 !== Number.parseInt(stripped[12], 10)) {
+    return false;
+  }
+  const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+  sum = 0;
+  for (let i = 0; i < 13; i++) {
+    sum += Number.parseInt(stripped[i], 10) * weights2[i];
+  }
+  remainder = sum % 11;
+  const digit2 = remainder < 2 ? 0 : 11 - remainder;
+  if (digit2 !== Number.parseInt(stripped[13], 10)) {
+    return false;
+  }
+  return true;
+}
+var EVP_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var PHONE_PATTERN = /^\+55\d{10,11}$/;
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function detectPixKeyType(key) {
+  const digitsOnly = key.replace(/\D/g, "");
+  if (EVP_PATTERN.test(key)) {
+    return "evp";
+  }
+  if (PHONE_PATTERN.test(key)) {
+    return "phone";
+  }
+  if (EMAIL_PATTERN.test(key)) {
+    return "email";
+  }
+  if (digitsOnly.length === 11 && digitsOnly === key && isValidCpf(key)) {
+    return "cpf";
+  }
+  if (digitsOnly.length === 14 && digitsOnly === key && isValidCnpj(key)) {
+    return "cnpj";
+  }
+  return null;
+}
+function isValidPixKey(key) {
+  return detectPixKeyType(key) !== null;
+}
+function isValidMonetaryValue(value) {
+  return /^\d+\.\d{2}$/.test(value);
+}
+
+// src/utils/qrcode.ts
+var ALIGNMENT_PATTERNS = {
+  2: [6, 18],
+  3: [6, 22],
+  4: [6, 26],
+  5: [6, 30],
+  6: [6, 34],
+  7: [6, 22, 38],
+  8: [6, 24, 42],
+  9: [6, 26, 46],
+  10: [6, 28, 50]
+};
+var MODE_BYTE = 4;
+var CAPACITY_M = {
+  1: 14,
+  2: 26,
+  3: 42,
+  4: 62,
+  5: 84,
+  6: 106,
+  7: 122,
+  8: 152,
+  9: 180,
+  10: 213
+};
+function getMinVersion(dataLength) {
+  for (let v = 1; v <= 10; v++) {
+    const cap = CAPACITY_M[v];
+    if (cap !== void 0 && dataLength <= cap) {
+      return v;
+    }
+  }
+  throw new Error(`Data too long for QR code (max ~213 bytes). Got ${dataLength} bytes.`);
+}
+function getModuleCount(version) {
+  return 17 + version * 4;
+}
+function generateQrCodeSvg(data, options = {}) {
+  const { size = 256, margin = 4, darkColor = "#000000", lightColor = "#FFFFFF" } = options;
+  const bytes = new TextEncoder().encode(data);
+  const version = getMinVersion(bytes.length);
+  const moduleCount = getModuleCount(version);
+  const matrix = createQrMatrix(bytes, version, moduleCount);
+  const cellSize = size / (moduleCount + margin * 2);
+  let paths = "";
+  for (let row = 0; row < moduleCount; row++) {
+    for (let col = 0; col < moduleCount; col++) {
+      if (matrix[row]?.[col]) {
+        const x = (col + margin) * cellSize;
+        const y = (row + margin) * cellSize;
+        paths += `M${x},${y}h${cellSize}v${cellSize}h-${cellSize}z`;
+      }
+    }
+  }
+  const totalSize = (moduleCount + margin * 2) * cellSize;
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${totalSize} ${totalSize}" width="${size}" height="${size}">`,
+    `<rect width="${totalSize}" height="${totalSize}" fill="${lightColor}"/>`,
+    `<path d="${paths}" fill="${darkColor}"/>`,
+    "</svg>"
+  ].join("");
+}
+function generateQrCodeDataUrl(data, options) {
+  const svg = generateQrCodeSvg(data, options);
+  const base64 = btoa(svg);
+  return `data:image/svg+xml;base64,${base64}`;
+}
+function createQrMatrix(data, version, size) {
+  const matrix = Array.from({ length: size }, () => Array(size).fill(false));
+  const reserved = Array.from({ length: size }, () => Array(size).fill(false));
+  placeFinderPattern(matrix, reserved, 0, 0);
+  placeFinderPattern(matrix, reserved, size - 7, 0);
+  placeFinderPattern(matrix, reserved, 0, size - 7);
+  for (let i = 8; i < size - 8; i++) {
+    const bit = i % 2 === 0;
+    matrix[6][i] = bit;
+    reserved[6][i] = true;
+    matrix[i][6] = bit;
+    reserved[i][6] = true;
+  }
+  if (version >= 2) {
+    const positions = ALIGNMENT_PATTERNS[version];
+    if (positions) {
+      for (const row of positions) {
+        for (const col of positions) {
+          if (reserved[row]?.[col]) continue;
+          placeAlignmentPattern(matrix, reserved, row, col);
+        }
+      }
+    }
+  }
+  reserveFormatAreas(reserved, size);
+  const dataBits = encodeDataBits(data, version);
+  placeDataBits(matrix, reserved, dataBits, size);
+  applyMask(matrix, reserved, size);
+  return matrix;
+}
+function placeFinderPattern(matrix, reserved, row, col) {
+  for (let r = -1; r <= 7; r++) {
+    for (let c = -1; c <= 7; c++) {
+      const mr = row + r;
+      const mc = col + c;
+      if (mr < 0 || mc < 0 || mr >= matrix.length || mc >= matrix.length) continue;
+      let dark = false;
+      if (r >= 0 && r <= 6 && c >= 0 && c <= 6) {
+        if (r === 0 || r === 6 || c === 0 || c === 6) dark = true;
+        else if (r >= 2 && r <= 4 && c >= 2 && c <= 4) dark = true;
+      }
+      matrix[mr][mc] = dark;
+      reserved[mr][mc] = true;
+    }
+  }
+}
+function placeAlignmentPattern(matrix, reserved, centerRow, centerCol) {
+  for (let r = -2; r <= 2; r++) {
+    for (let c = -2; c <= 2; c++) {
+      const mr = centerRow + r;
+      const mc = centerCol + c;
+      const dark = Math.abs(r) === 2 || Math.abs(c) === 2 || r === 0 && c === 0;
+      matrix[mr][mc] = dark;
+      reserved[mr][mc] = true;
+    }
+  }
+}
+function reserveFormatAreas(reserved, size) {
+  for (let i = 0; i < 9; i++) {
+    reserved[8][i] = true;
+    reserved[i][8] = true;
+  }
+  for (let i = 0; i < 8; i++) {
+    reserved[8][size - 1 - i] = true;
+  }
+  for (let i = 0; i < 7; i++) {
+    reserved[size - 1 - i][8] = true;
+  }
+  reserved[size - 8][8] = true;
+}
+function encodeDataBits(data, version) {
+  const bits = [];
+  pushBits(bits, MODE_BYTE, 4);
+  const countBits = version <= 9 ? 8 : 16;
+  pushBits(bits, data.length, countBits);
+  for (const byte of data) {
+    pushBits(bits, byte, 8);
+  }
+  const capacity = (CAPACITY_M[version] ?? 0) * 8;
+  const terminatorLength = Math.min(4, capacity - bits.length);
+  pushBits(bits, 0, terminatorLength);
+  while (bits.length % 8 !== 0) {
+    bits.push(0);
+  }
+  let padIndex = 0;
+  const padBytes = [236, 17];
+  while (bits.length < capacity) {
+    pushBits(bits, padBytes[padIndex % 2], 8);
+    padIndex++;
+  }
+  return bits;
+}
+function pushBits(bits, value, count) {
+  for (let i = count - 1; i >= 0; i--) {
+    bits.push(value >> i & 1);
+  }
+}
+function placeDataBits(matrix, reserved, bits, size) {
+  let bitIndex = 0;
+  let upward = true;
+  for (let col = size - 1; col >= 0; col -= 2) {
+    if (col === 6) col = 5;
+    const rows = upward ? Array.from({ length: size }, (_, i) => size - 1 - i) : Array.from({ length: size }, (_, i) => i);
+    for (const row of rows) {
+      for (const c of [col, col - 1]) {
+        if (c < 0) continue;
+        if (reserved[row]?.[c]) continue;
+        if (bitIndex < bits.length) {
+          matrix[row][c] = bits[bitIndex] === 1;
+          bitIndex++;
+        }
+      }
+    }
+    upward = !upward;
+  }
+}
+function applyMask(matrix, reserved, size) {
+  for (let row = 0; row < size; row++) {
+    for (let col = 0; col < size; col++) {
+      if (reserved[row]?.[col]) continue;
+      if ((row + col) % 2 === 0) {
+        matrix[row][col] = !matrix[row]?.[col];
+      }
+    }
+  }
+}
+
+// src/utils/date.ts
+function toISOString(date) {
+  return date.toISOString();
+}
+function createDateRange(startDaysAgo = 30) {
+  const fim = /* @__PURE__ */ new Date();
+  const inicio = /* @__PURE__ */ new Date();
+  inicio.setDate(inicio.getDate() - startDaysAgo);
+  return {
+    inicio: inicio.toISOString(),
+    fim: fim.toISOString()
+  };
+}
+function parseDate(isoString) {
+  const date = new Date(isoString);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid date string: ${isoString}`);
+  }
+  return date;
+}
+function formatDateOnly(date) {
+  return date.toISOString().split("T")[0];
+}
+
+// src/types/common.ts
+function isDevedorCpf(devedor) {
+  return "cpf" in devedor;
+}
+function isDevedorCnpj(devedor) {
+  return "cnpj" in devedor;
+}
+function isPagadorCpf(pagador) {
+  return "cpf" in pagador;
+}
+function isPagadorCnpj(pagador) {
+  return "cnpj" in pagador;
+}
+
+// src/webhook-handler/index.ts
+function parseWebhookPayload(body) {
+  let parsed;
+  if (typeof body === "string") {
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return { valid: false, error: "Invalid JSON body" };
+    }
+  } else {
+    parsed = body;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return { valid: false, error: "Body is not an object" };
+  }
+  const data = parsed;
+  if (!Array.isArray(data.pix)) {
+    return { valid: false, error: 'Missing or invalid "pix" array in payload' };
+  }
+  for (const [i, item] of data.pix.entries()) {
+    if (!item || typeof item !== "object") {
+      return { valid: false, error: `pix[${i}] is not an object` };
+    }
+    const pix = item;
+    if (typeof pix.endToEndId !== "string") {
+      return { valid: false, error: `pix[${i}].endToEndId is required` };
+    }
+    if (typeof pix.chave !== "string") {
+      return { valid: false, error: `pix[${i}].chave is required` };
+    }
+    if (typeof pix.valor !== "string") {
+      return { valid: false, error: `pix[${i}].valor is required` };
+    }
+    if (typeof pix.horario !== "string") {
+      return { valid: false, error: `pix[${i}].horario is required` };
+    }
+  }
+  return {
+    valid: true,
+    payload: parsed
+  };
+}
+
+exports.SICREDI_ISPB = SICREDI_ISPB;
+exports.SICREDI_URLS = SICREDI_URLS;
+exports.Sicredi = Sicredi;
+exports.SicrediApiError = SicrediApiError;
+exports.SicrediAuthError = SicrediAuthError;
+exports.SicrediCertificateError = SicrediCertificateError;
+exports.SicrediValidationError = SicrediValidationError;
+exports.createDateRange = createDateRange;
+exports.detectPixKeyType = detectPixKeyType;
+exports.formatDateOnly = formatDateOnly;
+exports.generateQrCodeDataUrl = generateQrCodeDataUrl;
+exports.generateQrCodeSvg = generateQrCodeSvg;
+exports.generateTxId = generateTxId;
+exports.isDevedorCnpj = isDevedorCnpj;
+exports.isDevedorCpf = isDevedorCpf;
+exports.isPagadorCnpj = isPagadorCnpj;
+exports.isPagadorCpf = isPagadorCpf;
+exports.isValidCnpj = isValidCnpj;
+exports.isValidCpf = isValidCpf;
+exports.isValidMonetaryValue = isValidMonetaryValue;
+exports.isValidPixKey = isValidPixKey;
+exports.isValidTxId = isValidTxId;
+exports.parseDate = parseDate;
+exports.parseWebhookPayload = parseWebhookPayload;
+exports.toISOString = toISOString;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map