@sanghosdk/js 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1395 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* sangho-sdk-js v0.1.2 — https://docs.sangho.ga/sdks/js */
+
+// core/errors.ts
+var KNOWN_ERROR_TYPES = [
+  "AUTHENTICATION_ERROR",
+  "PERMISSION_ERROR",
+  "NOT_FOUND_ERROR",
+  "CONFLICT_ERROR",
+  "VALIDATION_ERROR",
+  "RATE_LIMIT_ERROR",
+  "API_ERROR",
+  "NETWORK_ERROR",
+  "TIMEOUT_ERROR"
+];
+function resolveErrorType(defaultType, raw) {
+  const backendType = raw?.type?.toUpperCase();
+  if (backendType && KNOWN_ERROR_TYPES.includes(backendType)) {
+    return backendType;
+  }
+  return defaultType;
+}
+var SanghoError = class extends Error {
+  /**
+   * Catégorie large de l'erreur, une des 9 valeurs `SanghoErrorType`
+   * (`VALIDATION_ERROR`, `RATE_LIMIT_ERROR`, `NETWORK_ERROR`, ...).
+   * Utile pour un `switch`/branchement générique.
+   */
+  type;
+  /**
+   * Code métier précis renvoyé par le backend (`raw.code`), ex :
+   * `AMOUNT_TOO_SMALL`, `INSUFFICIENT_FUNDS`, `CUSTOMER_NOT_FOUND`,
+   * `INVALID_API_KEY`, `CURRENCY_NOT_IN_PLAN`... Le catalogue de codes est
+   * possédé et versionné côté backend et continuera de grandir — c'est
+   * pourquoi ce champ est typé `string` plutôt qu'une union fermée.
+   *
+   * Quand l'erreur n'a jamais atteint le backend (`SanghoNetworkError`,
+   * `SanghoTimeoutError` — pas de corps de réponse à lire), `code` retombe
+   * sur la même valeur que `type`.
+   */
+  code;
+  statusCode;
+  raw;
+  constructor(message, type = "API_ERROR", statusCode, raw) {
+    super(message);
+    this.name = "SanghoError";
+    this.type = resolveErrorType(type, raw);
+    this.code = raw?.code ?? this.type;
+    this.statusCode = statusCode;
+    this.raw = raw;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SanghoAuthError = class extends SanghoError {
+  constructor(message = "Invalid or missing API key.", raw) {
+    super(message, "AUTHENTICATION_ERROR", 401, raw);
+    this.name = "SanghoAuthError";
+  }
+};
+var SanghoPublicKeyError = class extends SanghoError {
+  constructor(message = "Public key not allowed for this operation.", raw) {
+    super(
+      message,
+      "PERMISSION_ERROR",
+      403,
+      raw
+      // ← raw transmis
+    );
+    this.name = "SanghoPublicKeyError";
+  }
+};
+var SanghoPermissionError = class extends SanghoError {
+  constructor(message = "You do not have permission to perform this action.", raw) {
+    super(message, "PERMISSION_ERROR", 403, raw);
+    this.name = "SanghoPermissionError";
+  }
+};
+var SanghoNotFoundError = class extends SanghoError {
+  constructor(message = "Resource not found.", raw) {
+    super(message, "NOT_FOUND_ERROR", 404, raw);
+    this.name = "SanghoNotFoundError";
+  }
+};
+var SanghoValidationError = class extends SanghoError {
+  fieldErrors;
+  param;
+  constructor(raw) {
+    const fields = typeof raw.detail === "object" ? raw.detail : raw.errors ?? {};
+    const summary = Object.entries(fields).map(([k, v]) => `${k}: ${v.join(", ")}`).join(" | ");
+    super(summary || raw.message || "Validation error", "VALIDATION_ERROR", 422, raw);
+    this.name = "SanghoValidationError";
+    this.fieldErrors = fields;
+  }
+};
+var SanghoRateLimitError = class extends SanghoError {
+  retryAfter;
+  constructor(retryAfter, raw) {
+    super(
+      raw?.message ?? `Rate limit exceeded.${retryAfter ? ` Retry after ${retryAfter}s.` : ""}`,
+      "RATE_LIMIT_ERROR",
+      429,
+      raw
+    );
+    this.name = "SanghoRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var SanghoIdempotencyError = class extends SanghoError {
+  constructor(raw) {
+    super(
+      "Idempotency key reused with different request parameters.",
+      "CONFLICT_ERROR",
+      409,
+      raw
+    );
+    this.name = "SanghoIdempotencyError";
+  }
+};
+var SanghoNetworkError = class extends SanghoError {
+  constructor(message = "Network error. Please check your connection.") {
+    super(message, "NETWORK_ERROR");
+    this.name = "SanghoNetworkError";
+  }
+};
+var SanghoTimeoutError = class extends SanghoError {
+  constructor(timeout) {
+    super(`Request timed out after ${timeout}ms.`, "TIMEOUT_ERROR");
+    this.name = "SanghoTimeoutError";
+  }
+};
+
+// core/http.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var SDK_VERSION = "__SDK_VERSION__";
+var HttpClient = class {
+  keyType;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.keyType = config.apiKey.startsWith("pk_") ? "public" : "secret";
+  }
+  assertSecretKey(methodName) {
+    if (this.keyType === "public") {
+      throw new SanghoPublicKeyError(
+        `The method "${methodName}" requires a Secret Key or a Terminal Session.`
+      );
+    }
+  }
+  async get(path, params) {
+    const url = this.buildURL(path, params);
+    return this.request("GET", url);
+  }
+  async post(path, body, idempotencyKey) {
+    const url = this.buildURL(path);
+    return this.request("POST", url, body, {
+      "Idempotency-Key": idempotencyKey ?? generateUUID()
+    });
+  }
+  async patch(path, body) {
+    const url = this.buildURL(path);
+    return this.request("PATCH", url, body);
+  }
+  async put(path, body) {
+    const url = this.buildURL(path);
+    return this.request("PUT", url, body);
+  }
+  async delete(path) {
+    const url = this.buildURL(path);
+    return this.request("DELETE", url);
+  }
+  async options(path) {
+    const url = this.buildURL(path);
+    return this.request("OPTIONS", url);
+  }
+  buildURL(path, params) {
+    const base = this.config.baseURL.replace(/\/$/, "");
+    const full = `${base}${path}`;
+    if (!params || Object.keys(params).length === 0) return full;
+    const search = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0 && v !== null) {
+        search.set(k, String(v));
+      }
+    }
+    const qs = search.toString();
+    return qs ? `${full}?${qs}` : full;
+  }
+  baseHeaders(extra) {
+    return {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "X-Sangho-SDK": `js/${SDK_VERSION}`,
+      "X-Sangho-Environment": this.config.sandbox ? "sandbox" : "live",
+      ...extra
+    };
+  }
+  async request(method, url, body, extraHeaders, attempt = 0) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: this.baseHeaders(extraHeaders),
+        signal: controller.signal,
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      });
+      clearTimeout(timer);
+      return await this.handleResponse(response);
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof SanghoError) {
+        if (this.isRetryable(err) && attempt < this.config.maxRetries) {
+          const delay = err instanceof SanghoRateLimitError && err.retryAfter ? err.retryAfter * 1e3 : Math.pow(2, attempt) * 500;
+          await this.sleep(delay);
+          return this.request(method, url, body, extraHeaders, attempt + 1);
+        }
+        throw err;
+      }
+      if (err instanceof DOMException && err.name === "AbortError") {
+        throw new SanghoTimeoutError(this.config.timeout);
+      }
+      if (err instanceof TypeError) {
+        if (attempt < this.config.maxRetries) {
+          await this.sleep(Math.pow(2, attempt) * 500);
+          return this.request(method, url, body, extraHeaders, attempt + 1);
+        }
+        throw new SanghoNetworkError(err.message);
+      }
+      throw err;
+    }
+  }
+  /**
+   * Détermine si une SanghoError est transitoire et mérite un retry :
+   * 429 (rate limit) ou 5xx (erreur serveur). Jamais les 4xx restants
+   * (400/401/403/404/409/422) — ce sont des erreurs permanentes côté client.
+   */
+  isRetryable(err) {
+    if (err instanceof SanghoRateLimitError) return true;
+    return typeof err.statusCode === "number" && err.statusCode >= 500;
+  }
+  async handleResponse(response) {
+    if (response.status === 204) return void 0;
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      data = {};
+    }
+    if (response.ok) return data;
+    const raw = data;
+    const errorResponse = {
+      message: raw["message"] ?? raw["detail"] ?? "API error",
+      type: raw["type"],
+      code: raw["code"],
+      detail: raw["detail"],
+      errors: raw["errors"],
+      status: response.status,
+      param: raw["param"]
+    };
+    const message = errorResponse.message;
+    const code = errorResponse.code?.toLowerCase();
+    switch (response.status) {
+      case 401:
+        throw new SanghoAuthError(message, errorResponse);
+      case 403:
+        if (code === "public_key_not_allowed") {
+          throw new SanghoPublicKeyError(message, errorResponse);
+        }
+        throw new SanghoPermissionError(message, errorResponse);
+      case 404:
+        throw new SanghoNotFoundError(message, errorResponse);
+      case 409:
+        throw new SanghoIdempotencyError(errorResponse);
+      case 422:
+        throw new SanghoValidationError(errorResponse);
+      case 429: {
+        const retryAfter = raw["retry_after"] ?? Number(response.headers.get("Retry-After") ?? 60);
+        throw new SanghoRateLimitError(retryAfter, errorResponse);
+      }
+      default:
+        throw new SanghoError(message, "API_ERROR", response.status, errorResponse);
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// modules/base.ts
+var BaseModule = class {
+  /** Client HTTP partagé — ne jamais exposer publiquement. */
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+};
+
+// modules/account.ts
+var AccountModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  account = {
+    retrieve: () => this._retrieve()
+  };
+  /**
+   * Retourne l'application associée à la clé secrète utilisée pour la requête.
+   * Équivalent de `apps.retrieve(id)` sans avoir à connaître l'ID au préalable —
+   * pratique comme "who am I" / health-check d'introspection.
+   */
+  _retrieve() {
+    this.http.assertSecretKey("account.retrieve");
+    return this.http.get("/account/");
+  }
+};
+
+// modules/apps.ts
+var AppsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  apps = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    delete: (id) => this._delete(id),
+    keys: (id) => this._keys(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("apps.list");
+    return this.http.get("/apps/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("apps.retrieve");
+    return this.http.get(`/apps/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("apps.create");
+    return this.http.post("/apps/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("apps.update");
+    return this.http.patch(`/apps/${id}/`, payloads);
+  }
+  _delete(id) {
+    this.http.assertSecretKey("apps.delete");
+    return this.http.delete(`/apps/${id}/`);
+  }
+  _keys(id) {
+    this.http.assertSecretKey("apps.keys");
+    return this.http.get(`/apps/${id}/keys/`);
+  }
+  _options() {
+    return this.http.options("/apps/");
+  }
+};
+
+// modules/addresses.ts
+var AddressesModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  addresses = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    delete: (id) => this._delete(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("addresses.list");
+    return this.http.get("/addresses/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("addresses.retrieve");
+    return this.http.get(`/addresses/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("addresses.create");
+    return this.http.post("/addresses/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("addresses.update");
+    return this.http.patch(`/addresses/${id}/`, payloads);
+  }
+  _delete(id) {
+    this.http.assertSecretKey("addresses.delete");
+    return this.http.delete(`/addresses/${id}/`);
+  }
+  _options() {
+    return this.http.options("/addresses/");
+  }
+};
+
+// modules/customers.ts
+var CustomersModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  customers = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    delete: (id) => this._delete(id),
+    listTransactions: (id, criteria) => this._listTransactions(id, criteria),
+    listPaymentMethods: (id) => this._listPaymentMethods(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("customers.list");
+    return this.http.get("/customers/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("customers.retrieve");
+    return this.http.get(`/customers/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("customers.create");
+    return this.http.post("/customers/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("customers.update");
+    return this.http.patch(`/customers/${id}/`, payloads);
+  }
+  _delete(id) {
+    this.http.assertSecretKey("customers.delete");
+    return this.http.delete(`/customers/${id}/`);
+  }
+  _listTransactions(id, criteria) {
+    this.http.assertSecretKey("customers.listTransactions");
+    return this.http.get(
+      `/customers/${id}/transactions/`,
+      criteria
+    );
+  }
+  _listPaymentMethods(id) {
+    this.http.assertSecretKey("customers.listPaymentMethods");
+    return this.http.get(
+      `/customers/${id}/payment-methods/`
+    );
+  }
+  _options() {
+    return this.http.options("/customers/");
+  }
+};
+
+// modules/products.ts
+var ProductsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  products = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    delete: (id) => this._delete(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("products.list");
+    return this.http.get("/products/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("products.retrieve");
+    return this.http.get(`/products/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("products.create");
+    return this.http.post("/products/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("products.update");
+    return this.http.patch(`/products/${id}/`, payloads);
+  }
+  _delete(id) {
+    this.http.assertSecretKey("products.delete");
+    return this.http.delete(`/products/${id}/`);
+  }
+  _options() {
+    return this.http.options("/products/");
+  }
+};
+
+// modules/payment-intents.ts
+var PaymentIntentsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  paymentIntents = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    delete: (id) => this._delete(id),
+    confirm: (id, payloads) => this._confirm(id, payloads),
+    capture: (id, payloads) => this._capture(id, payloads),
+    cancel: (id, payloads) => this._cancel(id, payloads),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("paymentIntents.list");
+    return this.http.get("/payment-intents/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("paymentIntents.retrieve");
+    return this.http.get(`/payment-intents/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("paymentIntents.create");
+    return this.http.post("/payment-intents/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("paymentIntents.update");
+    return this.http.patch(`/payment-intents/${id}/`, payloads);
+  }
+  _delete(id) {
+    this.http.assertSecretKey("paymentIntents.delete");
+    return this.http.delete(`/payment-intents/${id}/`);
+  }
+  _confirm(id, payloads) {
+    this.http.assertSecretKey("paymentIntents.confirm");
+    return this.http.post(`/payment-intents/${id}/confirm/`, payloads ?? {});
+  }
+  _capture(id, payloads) {
+    this.http.assertSecretKey("paymentIntents.capture");
+    return this.http.post(`/payment-intents/${id}/capture/`, payloads ?? {});
+  }
+  _cancel(id, payloads) {
+    this.http.assertSecretKey("paymentIntents.cancel");
+    return this.http.post(`/payment-intents/${id}/cancel/`, payloads ?? {});
+  }
+  _options() {
+    return this.http.options("/payment-intents/");
+  }
+};
+
+// modules/transactions.ts
+var TransactionsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  transactions = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    update: (id, payloads) => this._update(id, payloads),
+    cancel: (id) => this._cancel(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("transactions.list");
+    return this.http.get("/transactions/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("transactions.retrieve");
+    return this.http.get(`/transactions/${id}/`);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("transactions.update");
+    return this.http.patch(`/transactions/${id}/`, payloads);
+  }
+  _cancel(id) {
+    this.http.assertSecretKey("transactions.cancel");
+    return this.http.post(`/transactions/${id}/cancel/`, {});
+  }
+  _options() {
+    return this.http.options("/transactions/");
+  }
+};
+
+// modules/refunds.ts
+var RefundsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  refunds = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    cancel: (id) => this._cancel(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("refunds.list");
+    return this.http.get("/refunds/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("refunds.retrieve");
+    return this.http.get(`/refunds/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("refunds.create");
+    return this.http.post("/refunds/", payloads);
+  }
+  _cancel(id) {
+    this.http.assertSecretKey("refunds.cancel");
+    return this.http.post(`/refunds/${id}/cancel/`, {});
+  }
+  _options() {
+    return this.http.options("/refunds/");
+  }
+};
+
+// modules/invoices.ts
+var InvoicesModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  invoices = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    delete: (id) => this._delete(id),
+    send: (id) => this._send(id),
+    pay: (id) => this._pay(id),
+    void: (id) => this._void(id),
+    markUncollectible: (id) => this._markUncollectible(id),
+    getPdfUrl: (id) => this._getPdfUrl(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("invoices.list");
+    return this.http.get("/invoices/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("invoices.retrieve");
+    return this.http.get(`/invoices/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("invoices.create");
+    return this.http.post("/invoices/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("invoices.update");
+    return this.http.patch(`/invoices/${id}/`, payloads);
+  }
+  _delete(id) {
+    this.http.assertSecretKey("invoices.delete");
+    return this.http.delete(`/invoices/${id}/`);
+  }
+  _send(id) {
+    this.http.assertSecretKey("invoices.send");
+    return this.http.post(`/invoices/${id}/send/`, {});
+  }
+  _pay(id) {
+    this.http.assertSecretKey("invoices.pay");
+    return this.http.post(`/invoices/${id}/pay/`, {});
+  }
+  _void(id) {
+    this.http.assertSecretKey("invoices.void");
+    return this.http.post(`/invoices/${id}/void/`, {});
+  }
+  _markUncollectible(id) {
+    this.http.assertSecretKey("invoices.markUncollectible");
+    return this.http.post(`/invoices/${id}/mark-uncollectible/`, {});
+  }
+  _getPdfUrl(id) {
+    this.http.assertSecretKey("invoices.getPdfUrl");
+    return this.http.get(`/invoices/${id}/pdf/`);
+  }
+  _options() {
+    return this.http.options("/invoices/");
+  }
+};
+
+// modules/payment-links.ts
+var PaymentLinksModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  paymentLinks = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    delete: (id) => this._delete(id),
+    archive: (id) => this._archive(id),
+    restore: (id) => this._restore(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("paymentLinks.list");
+    return this.http.get("/payment-links/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("paymentLinks.retrieve");
+    return this.http.get(`/payment-links/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("paymentLinks.create");
+    return this.http.post("/payment-links/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("paymentLinks.update");
+    return this.http.patch(`/payment-links/${id}/`, payloads);
+  }
+  _delete(id) {
+    this.http.assertSecretKey("paymentLinks.delete");
+    return this.http.delete(`/payment-links/${id}/`);
+  }
+  _archive(id) {
+    this.http.assertSecretKey("paymentLinks.archive");
+    return this.http.post(`/payment-links/${id}/archive/`, {});
+  }
+  _restore(id) {
+    this.http.assertSecretKey("paymentLinks.restore");
+    return this.http.post(`/payment-links/${id}/restore/`, {});
+  }
+  _options() {
+    return this.http.options("/payment-links/");
+  }
+};
+
+// modules/checkout-sessions.ts
+var CheckoutSessionsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  checkoutSessions = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    expire: (id) => this._expire(id),
+    delete: (id) => this._delete(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("checkoutSessions.list");
+    return this.http.get("/checkout-sessions/", criteria);
+  }
+  _retrieve(id) {
+    return this.http.get(`/checkout-sessions/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("checkoutSessions.create");
+    return this.http.post("/checkout-sessions/", payloads);
+  }
+  _expire(id) {
+    this.http.assertSecretKey("checkoutSessions.expire");
+    return this.http.post(`/checkout-sessions/${id}/expire/`, {});
+  }
+  _delete(id) {
+    this.http.assertSecretKey("checkoutSessions.delete");
+    return this.http.delete(`/checkout-sessions/${id}/`);
+  }
+  _options() {
+    return this.http.options("/checkout-sessions/");
+  }
+};
+
+// modules/subscriptions.ts
+var SubscriptionsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  subscriptions = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    cancel: (id, payloads) => this._cancel(id, payloads),
+    reactivate: (id) => this._reactivate(id),
+    pause: (id) => this._pause(id),
+    resume: (id) => this._resume(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("subscriptions.list");
+    return this.http.get("/subscriptions/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("subscriptions.retrieve");
+    return this.http.get(`/subscriptions/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("subscriptions.create");
+    return this.http.post("/subscriptions/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("subscriptions.update");
+    return this.http.patch(`/subscriptions/${id}/`, payloads);
+  }
+  _cancel(id, payloads) {
+    this.http.assertSecretKey("subscriptions.cancel");
+    return this.http.post(`/subscriptions/${id}/cancel/`, payloads ?? {});
+  }
+  _reactivate(id) {
+    this.http.assertSecretKey("subscriptions.reactivate");
+    return this.http.post(`/subscriptions/${id}/reactivate/`, {});
+  }
+  _pause(id) {
+    this.http.assertSecretKey("subscriptions.pause");
+    return this.http.post(`/subscriptions/${id}/pause/`, {});
+  }
+  _resume(id) {
+    this.http.assertSecretKey("subscriptions.resume");
+    return this.http.post(`/subscriptions/${id}/resume/`, {});
+  }
+  _options() {
+    return this.http.options("/subscriptions/");
+  }
+};
+
+// modules/payment-methods.ts
+var PaymentMethodsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  paymentMethods = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    attach: (id, payloads) => this._attach(id, payloads),
+    detach: (id) => this._detach(id),
+    setDefault: (id) => this._setDefault(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("paymentMethods.list");
+    return this.http.get("/payment-methods/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("paymentMethods.retrieve");
+    return this.http.get(`/payment-methods/${id}/`);
+  }
+  _attach(id, payloads) {
+    this.http.assertSecretKey("paymentMethods.attach");
+    return this.http.post(`/payment-methods/${id}/attach/`, payloads);
+  }
+  _detach(id) {
+    this.http.assertSecretKey("paymentMethods.detach");
+    return this.http.post(`/payment-methods/${id}/detach/`, {});
+  }
+  _setDefault(id) {
+    this.http.assertSecretKey("paymentMethods.setDefault");
+    return this.http.post(`/payment-methods/${id}/set-default/`, {});
+  }
+  _options() {
+    return this.http.options("/payment-methods/");
+  }
+};
+
+// modules/receipts.ts
+var ReceiptsModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  receipts = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    getPdfUrl: (id) => this._getPdfUrl(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("receipts.list");
+    return this.http.get("/receipts/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("receipts.retrieve");
+    return this.http.get(`/receipts/${id}/`);
+  }
+  _getPdfUrl(id) {
+    this.http.assertSecretKey("receipts.getPdfUrl");
+    return this.http.get(`/receipts/${id}/pdf/`);
+  }
+  _options() {
+    return this.http.options("/receipts/");
+  }
+};
+
+// modules/webhooks.ts
+var WebhooksModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  webhooks = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    create: (payloads) => this._create(payloads),
+    update: (id, payloads) => this._update(id, payloads),
+    delete: (id) => this._delete(id),
+    disable: (id) => this._disable(id),
+    enable: (id) => this._enable(id),
+    rollSecret: (id) => this._rollSecret(id),
+    sendTestEvent: (id) => this._sendTestEvent(id),
+    listDeliveries: (id, criteria) => this._listDeliveries(id, criteria),
+    retrieveDelivery: (webhookId, deliveryId) => this._retrieveDelivery(webhookId, deliveryId),
+    retryDelivery: (webhookId, deliveryId) => this._retryDelivery(webhookId, deliveryId),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("webhooks.list");
+    return this.http.get("/webhooks/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("webhooks.retrieve");
+    return this.http.get(`/webhooks/${id}/`);
+  }
+  _create(payloads) {
+    this.http.assertSecretKey("webhooks.create");
+    return this.http.post("/webhooks/", payloads);
+  }
+  _update(id, payloads) {
+    this.http.assertSecretKey("webhooks.update");
+    return this.http.patch(`/webhooks/${id}/`, payloads);
+  }
+  _delete(id) {
+    this.http.assertSecretKey("webhooks.delete");
+    return this.http.delete(`/webhooks/${id}/`);
+  }
+  _disable(id) {
+    this.http.assertSecretKey("webhooks.disable");
+    return this.http.post(`/webhooks/${id}/disable/`, {});
+  }
+  _enable(id) {
+    this.http.assertSecretKey("webhooks.enable");
+    return this.http.post(`/webhooks/${id}/enable/`, {});
+  }
+  _rollSecret(id) {
+    this.http.assertSecretKey("webhooks.rollSecret");
+    return this.http.post(`/webhooks/${id}/roll-secret/`, {});
+  }
+  _sendTestEvent(id) {
+    this.http.assertSecretKey("webhooks.sendTestEvent");
+    return this.http.post(`/webhooks/${id}/test/`, {});
+  }
+  _listDeliveries(id, criteria) {
+    this.http.assertSecretKey("webhooks.listDeliveries");
+    return this.http.get(
+      `/webhooks/${id}/deliveries/`,
+      criteria
+    );
+  }
+  _retrieveDelivery(webhookId, deliveryId) {
+    this.http.assertSecretKey("webhooks.retrieveDelivery");
+    return this.http.get(
+      `/webhooks/${webhookId}/deliveries/${deliveryId}/`
+    );
+  }
+  _retryDelivery(webhookId, deliveryId) {
+    this.http.assertSecretKey("webhooks.retryDelivery");
+    return this.http.post(
+      `/webhooks/${webhookId}/deliveries/${deliveryId}/retry/`,
+      {}
+    );
+  }
+  _options() {
+    return this.http.options("/webhooks/");
+  }
+};
+
+// modules/security.ts
+var SecurityModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  security = {
+    retrieve: () => this._retrieve(),
+    update: (params) => this._update(params),
+    addAllowedIps: (ips) => this._addAllowedIps(ips),
+    removeAllowedIps: (ips) => this._removeAllowedIps(ips)
+  };
+  _retrieve() {
+    this.http.assertSecretKey("security.retrieve");
+    return this.http.get("/security/me/");
+  }
+  _update(params) {
+    this.http.assertSecretKey("security.update");
+    return this.http.patch("/security/update_me/", params);
+  }
+  // Pas d'action dédiée côté backend pour l'ajout/retrait d'IPs : on relit le
+  // profil, on recompose la liste complète, puis on la renvoie via update_me/.
+  async _addAllowedIps(ips) {
+    this.http.assertSecretKey("security.addAllowedIps");
+    const profile = await this._retrieve();
+    const merged = Array.from(/* @__PURE__ */ new Set([...profile.allowed_ips, ...ips]));
+    return this._update({ allowed_ips: merged });
+  }
+  async _removeAllowedIps(ips) {
+    this.http.assertSecretKey("security.removeAllowedIps");
+    const profile = await this._retrieve();
+    const remaining = profile.allowed_ips.filter((ip) => !ips.includes(ip));
+    return this._update({ allowed_ips: remaining });
+  }
+};
+
+// modules/partners.ts
+var PartnersModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  partners = {
+    list: (criteria) => this._list(criteria),
+    retrieve: (id) => this._retrieve(id),
+    options: () => this._options()
+  };
+  _list(criteria) {
+    this.http.assertSecretKey("partners.list");
+    return this.http.get("/partners/", criteria);
+  }
+  _retrieve(id) {
+    this.http.assertSecretKey("partners.retrieve");
+    return this.http.get(`/partners/${id}/`);
+  }
+  _options() {
+    return this.http.options("/partners/");
+  }
+};
+
+// modules/terminal.ts
+var TerminalModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  terminal = {
+    // ── Readers ───────────────────────────────────────────────────────
+    readers: {
+      list: (criteria) => this._listReaders(criteria),
+      retrieve: (id) => this._retrieveReader(id),
+      create: (payloads) => this._createReader(payloads),
+      update: (id, payloads) => this._updateReader(id, payloads),
+      disable: (id) => this._disableReader(id),
+      refreshToken: (id) => this._refreshToken(id),
+      heartbeat: (id) => this._heartbeat(id),
+      options: () => this._readerOptions()
+    },
+    // ── Sessions ──────────────────────────────────────────────────────
+    sessions: {
+      list: (criteria) => this._listSessions(criteria),
+      retrieve: (id) => this._retrieveSession(id),
+      create: (payloads) => this._createSession(payloads),
+      presentPaymentMethod: (id, payloads) => this._presentPayment(id, payloads),
+      pollStatus: (id) => this._pollStatus(id),
+      cancel: (id) => this._cancelSession(id),
+      options: () => this._sessionOptions()
+    },
+    // ── Offline sync ──────────────────────────────────────────────────
+    offline: {
+      sync: (payloads) => this._syncOffline(payloads),
+      list: (criteria) => this._listOffline(criteria),
+      options: () => this._offlineOptions()
+    }
+  };
+  // ── Reader methods ──────────────────────────────────────────────────────────
+  _listReaders(criteria) {
+    this.http.assertSecretKey("terminal.readers.list");
+    return this.http.get("/terminal/readers/", criteria);
+  }
+  _retrieveReader(id) {
+    this.http.assertSecretKey("terminal.readers.retrieve");
+    return this.http.get(`/terminal/readers/${id}/`);
+  }
+  _createReader(payloads) {
+    this.http.assertSecretKey("terminal.readers.create");
+    return this.http.post("/terminal/readers/", payloads);
+  }
+  _updateReader(id, payloads) {
+    this.http.assertSecretKey("terminal.readers.update");
+    return this.http.patch(`/terminal/readers/${id}/`, payloads);
+  }
+  _disableReader(id) {
+    this.http.assertSecretKey("terminal.readers.disable");
+    return this.http.delete(`/terminal/readers/${id}/`);
+  }
+  _refreshToken(id) {
+    this.http.assertSecretKey("terminal.readers.refreshToken");
+    return this.http.post(
+      `/terminal/readers/${id}/refresh-token/`,
+      {}
+    );
+  }
+  _heartbeat(id) {
+    this.http.assertSecretKey("terminal.readers.heartbeat");
+    return this.http.post(
+      `/terminal/readers/${id}/heartbeat/`,
+      {}
+    );
+  }
+  _readerOptions() {
+    return this.http.options("/terminal/readers/");
+  }
+  // ── Session methods ─────────────────────────────────────────────────────────
+  _listSessions(criteria) {
+    this.http.assertSecretKey("terminal.sessions.list");
+    return this.http.get("/terminal/sessions/", criteria);
+  }
+  _retrieveSession(id) {
+    this.http.assertSecretKey("terminal.sessions.retrieve");
+    return this.http.get(`/terminal/sessions/${id}/`);
+  }
+  _createSession(payloads) {
+    this.http.assertSecretKey("terminal.sessions.create");
+    return this.http.post("/terminal/sessions/", payloads);
+  }
+  _presentPayment(id, payloads) {
+    this.http.assertSecretKey("terminal.sessions.presentPaymentMethod");
+    return this.http.post(
+      `/terminal/sessions/${id}/present-payment-method/`,
+      payloads
+    );
+  }
+  _pollStatus(id) {
+    this.http.assertSecretKey("terminal.sessions.pollStatus");
+    return this.http.get(`/terminal/sessions/${id}/status/`);
+  }
+  _cancelSession(id) {
+    this.http.assertSecretKey("terminal.sessions.cancel");
+    return this.http.post(`/terminal/sessions/${id}/cancel/`, {});
+  }
+  _sessionOptions() {
+    return this.http.options("/terminal/sessions/");
+  }
+  // ── Offline methods ─────────────────────────────────────────────────────────
+  _syncOffline(payloads) {
+    this.http.assertSecretKey("terminal.offline.sync");
+    return this.http.post("/terminal/offline/sync/", payloads);
+  }
+  _listOffline(criteria) {
+    this.http.assertSecretKey("terminal.offline.list");
+    return this.http.get(
+      "/terminal/offline/sync/",
+      criteria
+    );
+  }
+  _offlineOptions() {
+    return this.http.options("/terminal/offline/sync/");
+  }
+};
+
+// modules/sandbox.ts
+var SandboxModule = class extends BaseModule {
+  constructor(http) {
+    super(http);
+    this.http = http;
+  }
+  sandbox = {
+    reset: () => this._reset()
+  };
+  /**
+   * Supprime toutes les données sandbox de l'application courante (customers,
+   * products, payment_intents, transactions, refunds, invoices,
+   * checkout_sessions, subscriptions, payment_methods, receipts).
+   *
+   * L'app elle-même, ses clés API et ses paramètres sont conservés.
+   * Bloqué par le backend si la clé utilisée est une clé live (`sk_prod_*`).
+   *
+   * @example
+   * await sangho.sandbox.reset()
+   */
+  _reset() {
+    this.http.assertSecretKey("sandbox.reset");
+    return this.http.post("/reset/", {});
+  }
+};
+
+// utils/webhook.ts
+var TOLERANCE_SECONDS = 300;
+async function constructEvent(payload, signature, secret, tolerance = TOLERANCE_SECONDS) {
+  const rawPayload = typeof payload === "string" ? new TextEncoder().encode(payload) : payload;
+  const parts = Object.fromEntries(
+    signature.split(",").map((part) => {
+      const idx = part.indexOf("=");
+      return [part.slice(0, idx), part.slice(idx + 1)];
+    })
+  );
+  const timestamp = Number(parts["t"]);
+  const expectedSig = parts["v1"];
+  if (!timestamp || !expectedSig) {
+    throw new SanghoError(
+      "Invalid Sangho-Signature header format.",
+      "API_ERROR"
+    );
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (Math.abs(now - timestamp) > tolerance) {
+    throw new SanghoError(
+      `Webhook timestamp too old (${Math.abs(now - timestamp)}s). Possible replay attack. Tolerance is ${tolerance}s.`,
+      "API_ERROR"
+    );
+  }
+  const signedPayload = `${timestamp}.${new TextDecoder().decode(rawPayload)}`;
+  const computedSig = await hmacSha256(secret, signedPayload);
+  if (!timingSafeEqual(computedSig, expectedSig)) {
+    throw new SanghoError(
+      "Webhook signature mismatch. Verify your webhook secret.",
+      "AUTHENTICATION_ERROR",
+      401
+    );
+  }
+  const body = JSON.parse(new TextDecoder().decode(rawPayload));
+  return body;
+}
+async function hmacSha256(secret, message) {
+  const encoder = new TextEncoder();
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    const key = await crypto.subtle.importKey(
+      "raw",
+      encoder.encode(secret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
+    return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  const { createHmac } = await import('crypto');
+  return createHmac("sha256", secret).update(message).digest("hex");
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
+// utils/mixins.ts
+function Mixins(BaseClass, ...Bases) {
+  class MixinsClass extends BaseClass {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- même raison : args passés tel quel aux constructeurs de Bases.
+    constructor(...args) {
+      super(...args);
+      Bases.forEach((Base) => {
+        const instance = new Base(...args);
+        Object.getOwnPropertyNames(instance).forEach((name) => {
+          if (name !== "constructor") {
+            const descriptor = Object.getOwnPropertyDescriptor(instance, name);
+            if (descriptor) {
+              Object.defineProperty(this, name, descriptor);
+            }
+          }
+        });
+        const proto = Base.prototype;
+        Object.getOwnPropertyNames(proto).forEach((name) => {
+          if (name !== "constructor") {
+            const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+            if (descriptor) {
+              Object.defineProperty(MixinsClass.prototype, name, descriptor);
+            }
+          }
+        });
+      });
+    }
+  }
+  return MixinsClass;
+}
+
+// client.ts
+var VALID_KEY_PREFIXES = ["pk_prod_", "sk_prod_", "pk_test_", "sk_test_"];
+function validateApiKey(key) {
+  if (!key || typeof key !== "string") {
+    throw new SanghoError(
+      "API key must be a non-empty string. Find your API keys at https://dash.sangho.ga/project/api-keys.",
+      "AUTHENTICATION_ERROR"
+    );
+  }
+  if (!VALID_KEY_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+    throw new SanghoError(
+      `Invalid API key format: "${key.slice(0, 10)}...". Keys must start with pk_prod_, sk_prod_, pk_test_, or sk_test_.`,
+      "AUTHENTICATION_ERROR"
+    );
+  }
+  if (key.length < 20) {
+    throw new SanghoError("API key is too short.", "AUTHENTICATION_ERROR");
+  }
+}
+function validateBaseURL(baseURL) {
+  let url;
+  try {
+    url = new URL(baseURL);
+  } catch {
+    throw new SanghoError(`Invalid baseURL: "${baseURL}".`, "API_ERROR");
+  }
+  const isLocal = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+  if (url.protocol !== "https:" && !isLocal) {
+    throw new SanghoError(
+      `Refusing to send API keys over a non-HTTPS baseURL: "${baseURL}". Use an https:// URL (localhost/127.0.0.1 are exempt for local development).`,
+      "API_ERROR"
+    );
+  }
+}
+var Sangho = class extends Mixins(
+  BaseModule,
+  AccountModule,
+  AppsModule,
+  AddressesModule,
+  CustomersModule,
+  ProductsModule,
+  PaymentIntentsModule,
+  TransactionsModule,
+  RefundsModule,
+  InvoicesModule,
+  PaymentLinksModule,
+  CheckoutSessionsModule,
+  SubscriptionsModule,
+  PaymentMethodsModule,
+  ReceiptsModule,
+  WebhooksModule,
+  SecurityModule,
+  PartnersModule,
+  TerminalModule,
+  SandboxModule
+) {
+  constructor(apiKey, options = {}) {
+    validateApiKey(apiKey);
+    const isSandbox = apiKey.startsWith("pk_test_") || apiKey.startsWith("sk_test_");
+    const baseURL = options.baseURL ?? "https://api.sangho.ga/v1";
+    validateBaseURL(baseURL);
+    const http = new HttpClient({
+      apiKey,
+      baseURL,
+      timeout: options.timeout ?? 3e4,
+      maxRetries: options.maxRetries ?? 3,
+      sandbox: isSandbox
+    });
+    super(http);
+  }
+  /**
+   * Vérifie et parse un événement webhook entrant.
+   * Valide la signature HMAC-SHA256 + protection anti-replay (5 min).
+   *
+   * @param payload   - Corps brut de la requête (Buffer ou string)
+   * @param signature - Header `Sangho-Signature` de la requête
+   * @param secret    - Secret du webhook (depuis le dashboard)
+   *
+   * @example
+   * ```typescript
+   * // Express
+   * app.post('/webhooks/sangho', express.raw({ type: 'application/json' }), (req, res) => {
+   *   const event = Sangho.constructEvent(
+   *     req.body,
+   *     req.headers['sangho-signature'],
+   *     process.env.SANGHO_WEBHOOK_SECRET
+   *   )
+   *   if (event.type === 'payment_intent.succeeded') {
+   *     await fulfillOrder(event.data)
+   *   }
+   *   res.json({ received: true })
+   * })
+   * ```
+   */
+  static constructEvent = constructEvent;
+};
+
+exports.Sangho = Sangho;
+exports.SanghoAuthError = SanghoAuthError;
+exports.SanghoError = SanghoError;
+exports.SanghoIdempotencyError = SanghoIdempotencyError;
+exports.SanghoNetworkError = SanghoNetworkError;
+exports.SanghoNotFoundError = SanghoNotFoundError;
+exports.SanghoPermissionError = SanghoPermissionError;
+exports.SanghoPublicKeyError = SanghoPublicKeyError;
+exports.SanghoRateLimitError = SanghoRateLimitError;
+exports.SanghoTimeoutError = SanghoTimeoutError;
+exports.SanghoValidationError = SanghoValidationError;
+exports.constructEvent = constructEvent;
+exports.default = Sangho;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map