paysafe-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1572 @@
+'use strict';
+
+// src/core/errors.ts
+var RETRYABLE_API_CODES = /* @__PURE__ */ new Set(["3028", "5000", "5001", "5002"]);
+var RETRYABLE_HTTP_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var PaysafeError = class _PaysafeError extends Error {
+  kind;
+  code;
+  httpStatus;
+  fieldErrors;
+  details;
+  retryable;
+  constructor(init) {
+    super(formatMessage(init));
+    this.name = "PaysafeError";
+    this.kind = init.kind;
+    this.code = init.code;
+    this.httpStatus = init.httpStatus;
+    this.fieldErrors = init.fieldErrors ?? [];
+    this.details = init.details;
+    this.retryable = init.retryable ?? false;
+    if (init.cause !== void 0) {
+      this.cause = init.cause;
+    }
+    Object.setPrototypeOf(this, _PaysafeError.prototype);
+  }
+  /** Whether the SDK's retry policy should attempt this request again. */
+  isRetryable() {
+    return this.retryable;
+  }
+  static fromApiResponse(body, httpStatus) {
+    const errObj = isRecord(body.error) ? body.error : void 0;
+    const code = errObj ? stringify(errObj.code) : "";
+    let message = "Unknown API error";
+    if (errObj && typeof errObj.message === "string" && errObj.message !== "") {
+      message = errObj.message;
+    } else if (typeof body.message === "string" && body.message !== "") {
+      message = body.message;
+    }
+    let fieldErrors = [];
+    if (errObj && Array.isArray(errObj.fieldErrors)) {
+      fieldErrors = errObj.fieldErrors.filter(isRecord).map((fe) => ({ field: stringify(fe.field), error: stringify(fe.error) }));
+    }
+    return new _PaysafeError({
+      kind: "api_error",
+      code,
+      message,
+      httpStatus,
+      fieldErrors,
+      details: body,
+      retryable: RETRYABLE_API_CODES.has(code) || RETRYABLE_HTTP_STATUSES.has(httpStatus)
+    });
+  }
+  static httpError(cause, timedOut) {
+    if (timedOut) {
+      return new _PaysafeError({
+        kind: "timeout",
+        message: "Request timed out",
+        retryable: true,
+        cause
+      });
+    }
+    return new _PaysafeError({
+      kind: "http_error",
+      message: `HTTP transport error: ${describeCause(cause)}`,
+      retryable: false,
+      cause
+    });
+  }
+  static rateLimited() {
+    return new _PaysafeError({
+      kind: "rate_limited",
+      message: "Rate limit exceeded. Reduce request frequency.",
+      retryable: true
+    });
+  }
+  static invalidParams(message) {
+    return new _PaysafeError({ kind: "invalid_params", message, retryable: false });
+  }
+  static invalidConfig(message) {
+    return new _PaysafeError({ kind: "invalid_config", message, retryable: false });
+  }
+  static webhookMismatch() {
+    return new _PaysafeError({
+      kind: "webhook_signature_mismatch",
+      message: "Webhook HMAC-SHA256 signature does not match.",
+      retryable: false
+    });
+  }
+  static decodeError(cause) {
+    return new _PaysafeError({
+      kind: "decode_error",
+      message: `Failed to decode response: ${describeCause(cause)}`,
+      retryable: false,
+      cause
+    });
+  }
+  static contextCanceled(cause) {
+    return new _PaysafeError({
+      kind: "context_canceled",
+      message: `Request aborted: ${describeCause(cause)}`,
+      retryable: false,
+      cause
+    });
+  }
+};
+function formatMessage(init) {
+  return init.code ? `paysafe: ${init.kind} [${init.code}]: ${init.message}` : `paysafe: ${init.kind}: ${init.message}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  if (value === null || value === void 0) return "";
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function describeCause(cause) {
+  if (cause instanceof Error) return cause.message;
+  return String(cause);
+}
+
+// src/core/config.ts
+var BASE_URLS = {
+  test: "https://api.test.paysafe.com",
+  production: "https://api.paysafe.com"
+};
+var PAYMENTS_PATH = "/paymenthub/v1";
+var SCHEDULER_PATH = "/subscriptionsplans/v1";
+var APPLICATIONS_PATH = "/merchant/v1";
+var FX_RATES_PATH = "/fxrates/v1";
+var BANK_ACCOUNT_VALIDATOR_PATH = "/bankaccountvalidator/v1";
+var CUSTOMER_IDENTIFICATION_PATH = "/customeridentification/v1";
+var ResolvedConfig = class {
+  username;
+  password;
+  environment;
+  accountId;
+  baseUrlOverride;
+  timeoutMs;
+  maxRetries;
+  retryBaseDelayMs;
+  rateLimit;
+  fetchImpl;
+  telemetryPrefix;
+  constructor(opts) {
+    this.username = opts.username;
+    this.password = opts.password;
+    this.environment = opts.environment ?? "test";
+    this.accountId = opts.accountId;
+    this.baseUrlOverride = opts.baseUrlOverride;
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.retryBaseDelayMs = opts.retryBaseDelayMs ?? 500;
+    this.rateLimit = opts.rateLimit ?? { limit: 100, windowMs: 1e3 };
+    this.telemetryPrefix = opts.telemetryPrefix ?? "paysafe";
+    const fetchImpl = opts.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw PaysafeError.invalidConfig(
+        "No fetch implementation available. Provide one via `fetch` in PaysafeClientOptions (the global fetch is unavailable in this runtime)."
+      );
+    }
+    this.fetchImpl = fetchImpl.bind(globalThis);
+    this.validate();
+  }
+  validate() {
+    if (!this.username) {
+      throw PaysafeError.invalidConfig("username is required");
+    }
+    if (!this.password) {
+      throw PaysafeError.invalidConfig("password is required");
+    }
+    if (this.environment !== "test" && this.environment !== "production") {
+      throw PaysafeError.invalidConfig('environment must be "test" or "production"');
+    }
+    if (this.maxRetries < 0) {
+      throw PaysafeError.invalidConfig("maxRetries must be >= 0");
+    }
+    if (this.rateLimit.limit <= 0 || this.rateLimit.windowMs <= 0) {
+      throw PaysafeError.invalidConfig("rateLimit must have a positive limit and windowMs");
+    }
+    if (this.timeoutMs <= 0) {
+      throw PaysafeError.invalidConfig("timeoutMs must be > 0");
+    }
+  }
+  baseUrl() {
+    return this.baseUrlOverride ?? BASE_URLS[this.environment];
+  }
+  paymentsUrl() {
+    return this.baseUrl() + PAYMENTS_PATH;
+  }
+  schedulerUrl() {
+    return this.baseUrl() + SCHEDULER_PATH;
+  }
+  applicationsUrl() {
+    return this.baseUrl() + APPLICATIONS_PATH;
+  }
+  fxRatesUrl() {
+    return this.baseUrl() + FX_RATES_PATH;
+  }
+  bankAccountValidatorUrl() {
+    return this.baseUrl() + BANK_ACCOUNT_VALIDATOR_PATH;
+  }
+  customerIdentificationUrl() {
+    return this.baseUrl() + CUSTOMER_IDENTIFICATION_PATH;
+  }
+  /** Computes the Base64-encoded HTTP Basic Auth header value. */
+  authHeader() {
+    const raw = `${this.username}:${this.password}`;
+    return `Basic ${base64Encode(raw)}`;
+  }
+  /** Returns `override` if non-empty, otherwise the configured default account ID. */
+  resolveAccountId(override) {
+    if (override) return override;
+    if (this.accountId) return this.accountId;
+    throw PaysafeError.invalidParams(
+      "accountId is required: pass it explicitly or set a default via PaysafeClientOptions.accountId"
+    );
+  }
+};
+function base64Encode(raw) {
+  if (typeof btoa === "function") {
+    return btoa(raw);
+  }
+  return Buffer.from(raw, "utf-8").toString("base64");
+}
+function configFromEnv(overrides = {}) {
+  const env = typeof process !== "undefined" ? process.env : void 0;
+  if (!env) {
+    throw PaysafeError.invalidConfig(
+      "configFromEnv() requires a Node.js-like `process.env`; pass options explicitly in this runtime."
+    );
+  }
+  const base = {
+    username: env.PAYSAFE_USERNAME ?? "",
+    password: env.PAYSAFE_PASSWORD ?? ""
+  };
+  if (env.PAYSAFE_ENVIRONMENT === "production") {
+    base.environment = "production";
+  }
+  if (env.PAYSAFE_ACCOUNT_ID) {
+    base.accountId = env.PAYSAFE_ACCOUNT_ID;
+  }
+  return { ...base, ...overrides };
+}
+
+// src/core/telemetry.ts
+function hasStatusCode(value) {
+  return typeof value === "object" && value !== null && "httpStatus" in value;
+}
+async function span(hook, meta, fn) {
+  const start = Date.now();
+  hook?.onStart?.(meta);
+  try {
+    const result = await fn();
+    hook?.onStop?.({
+      ...meta,
+      durationMs: Date.now() - start,
+      httpStatus: 0,
+      ok: true
+    });
+    return result;
+  } catch (error) {
+    const httpStatus = hasStatusCode(error) ? error.httpStatus ?? 0 : 0;
+    hook?.onStop?.({
+      ...meta,
+      durationMs: Date.now() - start,
+      httpStatus,
+      ok: false,
+      error
+    });
+    throw error;
+  }
+}
+
+// src/core/http-client.ts
+var SDK_USER_AGENT = "paysafe-sdk/1.0.0 (+https://github.com/iamkanishka/paysafe-sdk)";
+var MAX_JITTER_MS = 100;
+function backoffDelayMs(baseMs, attempt) {
+  const multiplier = 2 ** attempt;
+  const jitter = Math.random() * MAX_JITTER_MS;
+  return baseMs * multiplier + jitter;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(PaysafeError.contextCanceled(signal.reason));
+      },
+      { once: true }
+    );
+  });
+}
+async function decodeErrorBody(response) {
+  const text = await response.text();
+  if (!text) return {};
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return { message: text };
+  } catch {
+    return { message: text };
+  }
+}
+var HttpTransport = class {
+  constructor(cfg, limiter, hook) {
+    this.cfg = cfg;
+    this.limiter = limiter;
+    this.hook = hook;
+  }
+  cfg;
+  limiter;
+  hook;
+  /**
+   * Performs the HTTP round trip and returns the raw response body as
+   * text. Used directly for endpoints with no JSON object response body
+   * (e.g. `DELETE`).
+   */
+  async raw(options) {
+    const meta = {
+      prefix: this.cfg.telemetryPrefix,
+      api: options.api,
+      method: options.method,
+      path: options.url,
+      operation: options.operation
+    };
+    return span(this.hook, meta, async () => {
+      this.limiter.allow(this.cfg.username, this.cfg.rateLimit.limit, this.cfg.rateLimit.windowMs);
+      return this.doWithRetry(options, 0);
+    });
+  }
+  /**
+   * Performs the HTTP round trip and decodes the JSON response body as
+   * `T`. This is the common case used by nearly every resource method.
+   */
+  async do(options) {
+    const raw = await this.raw(options);
+    if (!raw) {
+      return {};
+    }
+    try {
+      return JSON.parse(raw);
+    } catch (cause) {
+      throw PaysafeError.decodeError(cause);
+    }
+  }
+  async doWithRetry(options, attempt) {
+    try {
+      return await this.doOnce(options);
+    } catch (err) {
+      const retryable = err instanceof PaysafeError && err.isRetryable();
+      if (retryable && attempt < this.cfg.maxRetries) {
+        const delay = backoffDelayMs(this.cfg.retryBaseDelayMs, attempt);
+        await sleep(delay, options.signal);
+        return this.doWithRetry(options, attempt + 1);
+      }
+      throw err;
+    }
+  }
+  async doOnce(options) {
+    const controller = new AbortController();
+    const timeoutTimer = setTimeout(
+      () => controller.abort(new Error("timeout")),
+      this.cfg.timeoutMs
+    );
+    if (options.signal) {
+      if (options.signal.aborted) {
+        controller.abort(options.signal.reason);
+      } else {
+        options.signal.addEventListener("abort", () => controller.abort(options.signal?.reason), {
+          once: true
+        });
+      }
+    }
+    const headers = {
+      Authorization: this.cfg.authHeader(),
+      Accept: "application/json",
+      "User-Agent": SDK_USER_AGENT
+    };
+    let requestBody;
+    if (options.body !== void 0) {
+      try {
+        requestBody = JSON.stringify(options.body);
+      } catch (cause) {
+        clearTimeout(timeoutTimer);
+        throw PaysafeError.invalidParams(`failed to encode request body: ${String(cause)}`);
+      }
+      headers["Content-Type"] = "application/json";
+    }
+    let response;
+    try {
+      response = await this.cfg.fetchImpl(options.url, {
+        method: options.method,
+        headers,
+        body: requestBody,
+        signal: controller.signal
+      });
+    } catch (cause) {
+      clearTimeout(timeoutTimer);
+      const timedOut = controller.signal.aborted;
+      throw PaysafeError.httpError(cause, timedOut);
+    }
+    clearTimeout(timeoutTimer);
+    if (response.ok) {
+      return response.text();
+    }
+    const errorBody = await decodeErrorBody(response);
+    throw PaysafeError.fromApiResponse(errorBody, response.status);
+  }
+};
+
+// src/core/rate-limiter.ts
+function newBucket(limit, windowMs) {
+  return {
+    capacity: limit,
+    tokens: limit,
+    refillRatePerMs: limit / windowMs,
+    updatedAt: Date.now()
+  };
+}
+function tryConsume(bucket) {
+  const now = Date.now();
+  const elapsedMs = now - bucket.updatedAt;
+  bucket.updatedAt = now;
+  bucket.tokens = Math.min(bucket.capacity, bucket.tokens + elapsedMs * bucket.refillRatePerMs);
+  if (bucket.tokens >= 1) {
+    bucket.tokens -= 1;
+    return true;
+  }
+  return false;
+}
+var RateLimiter = class {
+  buckets = /* @__PURE__ */ new Map();
+  bucketFor(key, limit, windowMs) {
+    let bucket = this.buckets.get(key);
+    if (!bucket) {
+      bucket = newBucket(limit, windowMs);
+      this.buckets.set(key, bucket);
+    }
+    return bucket;
+  }
+  /**
+   * Checks (and, if permitted, consumes) one token for `key`. Throws a
+   * {@link PaysafeError} with `kind === "rate_limited"` if the bucket is
+   * exhausted.
+   */
+  allow(key, limit, windowMs) {
+    const window = windowMs > 0 ? windowMs : 1e3;
+    const bucket = this.bucketFor(key, limit, window);
+    if (!tryConsume(bucket)) {
+      throw PaysafeError.rateLimited();
+    }
+  }
+};
+
+// src/types/shared.ts
+function findLinkByRel(links, rel) {
+  return links?.find((link) => link.rel === rel)?.href;
+}
+
+// src/resources/payment-handles.ts
+var API_NAME = "payments";
+var PaymentHandlesResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /**
+   * Tokenizes a payment instrument, returning a Payment Handle. If
+   * `req.accountId` is omitted, the client's default account ID is used.
+   */
+  async create(req, signal) {
+    const accountId = req.accountId ?? this.cfg.resolveAccountId();
+    const body = { ...req, accountId };
+    const url = `${this.cfg.paymentsUrl()}/paymenthandles`;
+    return this.transport.do({
+      api: API_NAME,
+      operation: "paymentHandles.create",
+      method: "POST",
+      url,
+      body,
+      signal
+    });
+  }
+  /**
+   * Retrieves a Payment Handle by ID. Useful for polling status if
+   * webhooks are not received; always verify via `get` after receiving a
+   * webhook before trusting the status.
+   */
+  async get(paymentHandleId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/paymenthandles/${encodeURIComponent(paymentHandleId)}`;
+    return this.transport.do({
+      api: API_NAME,
+      operation: "paymentHandles.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+};
+function paymentHandleRedirectUrl(handle) {
+  if (handle.action !== "REDIRECT") return void 0;
+  return findLinkByRel(handle.links, "payment_redirect");
+}
+function paymentHandleRequiresAction(handle) {
+  return handle.action === "REDIRECT";
+}
+
+// src/resources/payments.ts
+var API_NAME2 = "payments";
+var PaymentsResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Creates a payment using a `paymentHandleToken` from a `PAYABLE` Payment Handle. */
+  async create(req, signal) {
+    const url = `${this.cfg.paymentsUrl()}/payments`;
+    return this.transport.do({
+      api: API_NAME2,
+      operation: "payments.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves a payment by ID. */
+  async get(paymentId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/payments/${encodeURIComponent(paymentId)}`;
+    return this.transport.do({
+      api: API_NAME2,
+      operation: "payments.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Returns payments matching the given filter. */
+  async list(filter = {}, signal) {
+    const query = new URLSearchParams();
+    if (filter.merchantRefNum) query.set("merchantRefNum", filter.merchantRefNum);
+    if (filter.startDate) query.set("startDate", filter.startDate);
+    if (filter.endDate) query.set("endDate", filter.endDate);
+    if (filter.limit !== void 0) query.set("limit", String(filter.limit));
+    if (filter.offset !== void 0) query.set("offset", String(filter.offset));
+    const qs = query.toString();
+    const url = `${this.cfg.paymentsUrl()}/payments${qs ? `?${qs}` : ""}`;
+    const resp = await this.transport.do({
+      api: API_NAME2,
+      operation: "payments.list",
+      method: "GET",
+      url,
+      signal
+    });
+    return resp.payments;
+  }
+  /** Cancels an authorized (not-yet-settled) payment. */
+  async cancel(paymentId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/payments/${encodeURIComponent(paymentId)}/cancels`;
+    return this.transport.do({
+      api: API_NAME2,
+      operation: "payments.cancel",
+      method: "POST",
+      url,
+      body: {},
+      signal
+    });
+  }
+};
+
+// src/resources/settlements.ts
+var API_NAME3 = "payments";
+var SettlementsResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Settles (captures) an authorized payment by payment ID. */
+  async create(paymentId, req, signal) {
+    const url = `${this.cfg.paymentsUrl()}/payments/${encodeURIComponent(paymentId)}/settlements`;
+    return this.transport.do({
+      api: API_NAME3,
+      operation: "settlements.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves a settlement by ID. */
+  async get(settlementId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/settlements/${encodeURIComponent(settlementId)}`;
+    return this.transport.do({
+      api: API_NAME3,
+      operation: "settlements.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Cancels a pending settlement. */
+  async cancel(settlementId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/settlements/${encodeURIComponent(settlementId)}/cancels`;
+    return this.transport.do({
+      api: API_NAME3,
+      operation: "settlements.cancel",
+      method: "POST",
+      url,
+      body: {},
+      signal
+    });
+  }
+};
+
+// src/resources/refunds.ts
+var API_NAME4 = "payments";
+var RefundsResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Issues a refund for a completed payment or settlement. */
+  async create(settlementId, req, signal) {
+    const url = `${this.cfg.paymentsUrl()}/settlements/${encodeURIComponent(settlementId)}/refunds`;
+    return this.transport.do({
+      api: API_NAME4,
+      operation: "refunds.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves a refund by ID. */
+  async get(refundId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/refunds/${encodeURIComponent(refundId)}`;
+    return this.transport.do({
+      api: API_NAME4,
+      operation: "refunds.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Cancels a pending refund. */
+  async cancel(refundId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/refunds/${encodeURIComponent(refundId)}/cancels`;
+    return this.transport.do({
+      api: API_NAME4,
+      operation: "refunds.cancel",
+      method: "POST",
+      url,
+      body: {},
+      signal
+    });
+  }
+};
+
+// src/resources/payouts.ts
+var API_NAME5 = "payments";
+var PayoutsResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /**
+   * Creates a standalone credit (payout for non-iGaming merchants). The
+   * Payment Handle must have `transactionType: "STANDALONE_CREDIT"`.
+   */
+  async standaloneCredit(req, signal) {
+    const accountId = req.accountId ?? this.cfg.resolveAccountId();
+    const body = { ...req, accountId };
+    const url = `${this.cfg.paymentsUrl()}/standalonecredits`;
+    return this.transport.do({
+      api: API_NAME5,
+      operation: "payouts.standaloneCredit",
+      method: "POST",
+      url,
+      body,
+      signal
+    });
+  }
+  /**
+   * Creates an original credit (payout for iGaming merchants). The
+   * Payment Handle must have `transactionType: "ORIGINAL_CREDIT"`.
+   */
+  async originalCredit(req, signal) {
+    const accountId = req.accountId ?? this.cfg.resolveAccountId();
+    const body = { ...req, accountId };
+    const url = `${this.cfg.paymentsUrl()}/originalcredits`;
+    return this.transport.do({
+      api: API_NAME5,
+      operation: "payouts.originalCredit",
+      method: "POST",
+      url,
+      body,
+      signal
+    });
+  }
+  /** Retrieves a standalone credit by ID. */
+  async getStandaloneCredit(creditId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/standalonecredits/${encodeURIComponent(creditId)}`;
+    return this.transport.do({
+      api: API_NAME5,
+      operation: "payouts.getStandaloneCredit",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Retrieves an original credit by ID. */
+  async getOriginalCredit(creditId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/originalcredits/${encodeURIComponent(creditId)}`;
+    return this.transport.do({
+      api: API_NAME5,
+      operation: "payouts.getOriginalCredit",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Cancels a standalone credit. */
+  async cancelStandaloneCredit(creditId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/standalonecredits/${encodeURIComponent(creditId)}/cancels`;
+    return this.transport.do({
+      api: API_NAME5,
+      operation: "payouts.cancelStandaloneCredit",
+      method: "POST",
+      url,
+      body: {},
+      signal
+    });
+  }
+};
+
+// src/resources/verifications.ts
+var API_NAME6 = "payments";
+var VerificationsResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Creates a card verification. */
+  async create(req, signal) {
+    const url = `${this.cfg.paymentsUrl()}/verifications`;
+    return this.transport.do({
+      api: API_NAME6,
+      operation: "verifications.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves a verification by ID. */
+  async get(verificationId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/verifications/${encodeURIComponent(verificationId)}`;
+    return this.transport.do({
+      api: API_NAME6,
+      operation: "verifications.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+};
+
+// src/resources/customers.ts
+var API_NAME7 = "payments";
+var CustomersResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Creates a customer profile in the vault. */
+  async create(req, signal) {
+    const accountId = req.accountId ?? this.cfg.resolveAccountId();
+    const body = { ...req, accountId };
+    const url = `${this.cfg.paymentsUrl()}/customers`;
+    return this.transport.do({
+      api: API_NAME7,
+      operation: "customers.create",
+      method: "POST",
+      url,
+      body,
+      signal
+    });
+  }
+  /** Retrieves a customer profile by Paysafe's customer ID. */
+  async get(customerId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/customers/${encodeURIComponent(customerId)}`;
+    return this.transport.do({
+      api: API_NAME7,
+      operation: "customers.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Retrieves a customer profile by your own `merchantCustomerId`. */
+  async getByMerchantCustomerId(merchantCustomerId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/customers?merchantCustomerId=${encodeURIComponent(merchantCustomerId)}`;
+    return this.transport.do({
+      api: API_NAME7,
+      operation: "customers.getByMerchantCustomerId",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Updates a customer profile. Only the fields set in `req` are changed server-side. */
+  async update(customerId, req, signal) {
+    const url = `${this.cfg.paymentsUrl()}/customers/${encodeURIComponent(customerId)}`;
+    return this.transport.do({
+      api: API_NAME7,
+      operation: "customers.update",
+      method: "PUT",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Deletes a customer profile. */
+  async delete(customerId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/customers/${encodeURIComponent(customerId)}`;
+    await this.transport.raw({
+      api: API_NAME7,
+      operation: "customers.delete",
+      method: "DELETE",
+      url,
+      signal
+    });
+  }
+  /**
+   * Converts a single-use token (SUT) returned from an initial payment
+   * into a multi-use token (MUT) attached to the customer profile,
+   * enabling saved-card/recurring flows.
+   */
+  async createPaymentHandle(customerId, req, signal) {
+    const url = `${this.cfg.paymentsUrl()}/customers/${encodeURIComponent(customerId)}/paymenthandles`;
+    return this.transport.do({
+      api: API_NAME7,
+      operation: "customers.createPaymentHandle",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Lists all saved payment handles (saved instruments) for a customer. */
+  async listPaymentHandles(customerId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/customers/${encodeURIComponent(customerId)}/paymenthandles`;
+    const resp = await this.transport.do({
+      api: API_NAME7,
+      operation: "customers.listPaymentHandles",
+      method: "GET",
+      url,
+      signal
+    });
+    return resp.paymentHandles;
+  }
+  /** Deletes a specific saved payment handle for a customer. */
+  async deletePaymentHandle(customerId, handleId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/customers/${encodeURIComponent(customerId)}/paymenthandles/${encodeURIComponent(handleId)}`;
+    await this.transport.raw({
+      api: API_NAME7,
+      operation: "customers.deletePaymentHandle",
+      method: "DELETE",
+      url,
+      signal
+    });
+  }
+  /**
+   * Tokenizes the customer's entire saved profile — profile details,
+   * saved cards, addresses, and bank mandates — into one short-lived
+   * token valid for 900 seconds. Used to display a returning customer's
+   * saved instruments, or to re-collect a one-time CVV for a saved card.
+   */
+  async createSingleUseCustomerToken(customerId, signal) {
+    const url = `${this.cfg.paymentsUrl()}/customers/${encodeURIComponent(customerId)}/singleusecustomertokens`;
+    return this.transport.do({
+      api: API_NAME7,
+      operation: "customers.createSingleUseCustomerToken",
+      method: "POST",
+      url,
+      body: {},
+      signal
+    });
+  }
+};
+
+// src/resources/applications.ts
+var API_NAME8 = "applications";
+var ApplicationsResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Creates a draft merchant application. */
+  async create(req, signal) {
+    const url = `${this.cfg.applicationsUrl()}/applications`;
+    return this.transport.do({
+      api: API_NAME8,
+      operation: "applications.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves an application by ID. */
+  async get(applicationId, signal) {
+    const url = `${this.cfg.applicationsUrl()}/applications/${encodeURIComponent(applicationId)}`;
+    return this.transport.do({
+      api: API_NAME8,
+      operation: "applications.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Updates a draft application. Only possible before `submit` is called. */
+  async update(applicationId, req, signal) {
+    const url = `${this.cfg.applicationsUrl()}/applications/${encodeURIComponent(applicationId)}`;
+    return this.transport.do({
+      api: API_NAME8,
+      operation: "applications.update",
+      method: "PUT",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /**
+   * Sends the application to Paysafe for review. After this call
+   * succeeds, the application can no longer be modified via the API.
+   */
+  async submit(applicationId, signal) {
+    const url = `${this.cfg.applicationsUrl()}/applications/${encodeURIComponent(applicationId)}`;
+    return this.transport.do({
+      api: API_NAME8,
+      operation: "applications.submit",
+      method: "PATCH",
+      url,
+      body: {},
+      signal
+    });
+  }
+  /** Retrieves the terms the merchant must accept before processing can begin. */
+  async getTermsAndConditions(applicationId, signal) {
+    const url = `${this.cfg.applicationsUrl()}/applications/${encodeURIComponent(applicationId)}/termsandconditions`;
+    return this.transport.do({
+      api: API_NAME8,
+      operation: "applications.getTermsAndConditions",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /**
+   * Attaches a supporting document to an application (e.g. requested by
+   * a credit underwriter during review). Documents can be uploaded before
+   * or after submission.
+   */
+  async uploadDocument(applicationId, req, signal) {
+    const url = `${this.cfg.applicationsUrl()}/applications/${encodeURIComponent(applicationId)}/documents`;
+    return this.transport.do({
+      api: API_NAME8,
+      operation: "applications.uploadDocument",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+};
+
+// src/resources/plans.ts
+var API_NAME9 = "scheduler";
+var PlansResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /**
+   * Creates a recurring billing plan under `accountId` (or the client's
+   * default account ID if `accountId` is omitted).
+   */
+  async create(accountId, req, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/plans`;
+    return this.transport.do({
+      api: API_NAME9,
+      operation: "plans.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves a plan by ID. */
+  async get(accountId, planId, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/plans/${encodeURIComponent(planId)}`;
+    return this.transport.do({
+      api: API_NAME9,
+      operation: "plans.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Lists all billing plans for an account. */
+  async list(accountId, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/plans`;
+    const resp = await this.transport.do({
+      api: API_NAME9,
+      operation: "plans.list",
+      method: "GET",
+      url,
+      signal
+    });
+    return resp.plans;
+  }
+  /**
+   * Updates a plan's mutable fields. Keep amount increases below 20% to
+   * comply with card scheme guidelines. Discontinuing a plan prevents new
+   * subscriptions but does not affect existing ones.
+   */
+  async update(accountId, planId, req, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/plans/${encodeURIComponent(planId)}`;
+    return this.transport.do({
+      api: API_NAME9,
+      operation: "plans.update",
+      method: "PATCH",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Discontinues a plan. */
+  async delete(accountId, planId, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/plans/${encodeURIComponent(planId)}`;
+    await this.transport.raw({
+      api: API_NAME9,
+      operation: "plans.delete",
+      method: "DELETE",
+      url,
+      signal
+    });
+  }
+};
+
+// src/resources/subscriptions.ts
+var API_NAME10 = "scheduler";
+var SubscriptionsResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Creates a subscription for a customer under a plan. */
+  async create(accountId, req, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/subscriptions`;
+    return this.transport.do({
+      api: API_NAME10,
+      operation: "subscriptions.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves a subscription by ID. */
+  async get(accountId, subscriptionId, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/subscriptions/${encodeURIComponent(subscriptionId)}`;
+    return this.transport.do({
+      api: API_NAME10,
+      operation: "subscriptions.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /** Lists subscriptions matching the given filter. */
+  async list(accountId, filter = {}, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const query = new URLSearchParams();
+    if (filter.planId) query.set("planId", filter.planId);
+    if (filter.status) query.set("status", filter.status);
+    if (filter.merchantCustomerId) query.set("merchantCustomerId", filter.merchantCustomerId);
+    if (filter.limit !== void 0) query.set("limit", String(filter.limit));
+    if (filter.offset !== void 0) query.set("offset", String(filter.offset));
+    const qs = query.toString();
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/subscriptions${qs ? `?${qs}` : ""}`;
+    const resp = await this.transport.do({
+      api: API_NAME10,
+      operation: "subscriptions.list",
+      method: "GET",
+      url,
+      signal
+    });
+    return resp.subscriptions;
+  }
+  /**
+   * Updates a subscription: extend cycles (`numCycles`), apply a discount
+   * (`discountAmount`/`discountNumPayments`), or change `status` directly.
+   * Prefer `cancel`/`suspend`/`reactivate` for status transitions.
+   */
+  async update(accountId, subscriptionId, req, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.schedulerUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/subscriptions/${encodeURIComponent(subscriptionId)}`;
+    return this.transport.do({
+      api: API_NAME10,
+      operation: "subscriptions.update",
+      method: "PATCH",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Cancels a subscription immediately. */
+  async cancel(accountId, subscriptionId, signal) {
+    return this.update(accountId, subscriptionId, { status: "CANCELLED" }, signal);
+  }
+  /** Pauses billing on a subscription; it can later be reactivated. */
+  async suspend(accountId, subscriptionId, signal) {
+    return this.update(accountId, subscriptionId, { status: "SUSPENDED" }, signal);
+  }
+  /**
+   * Re-activates a suspended subscription. The last failed payment is
+   * retried; subsequent cycles resume on their original schedule.
+   */
+  async reactivate(accountId, subscriptionId, signal) {
+    return this.update(accountId, subscriptionId, { status: "ACTIVE" }, signal);
+  }
+};
+
+// src/resources/fx-rates.ts
+var API_NAME11 = "fx_rates";
+var FxRatesResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Gets a guaranteed FX rate for a currency pair. */
+  async getRate(accountId, req, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.fxRatesUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/fxrates`;
+    return this.transport.do({
+      api: API_NAME11,
+      operation: "fxRates.getRate",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves a specific FX rate by quote ID. */
+  async getQuote(accountId, quoteId, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.fxRatesUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/fxrates/${encodeURIComponent(quoteId)}`;
+    return this.transport.do({
+      api: API_NAME11,
+      operation: "fxRates.getQuote",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+};
+
+// src/resources/customer-identity.ts
+var API_NAME12 = "customer_identity";
+var CustomerIdentityResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Submits an identity verification request. */
+  async verify(req, signal) {
+    const url = `${this.cfg.customerIdentificationUrl()}/identityprofiles`;
+    return this.transport.do({
+      api: API_NAME12,
+      operation: "customerIdentity.verify",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /** Retrieves a previously submitted identity profile by ID. */
+  async get(profileId, signal) {
+    const url = `${this.cfg.customerIdentificationUrl()}/identityprofiles/${encodeURIComponent(profileId)}`;
+    return this.transport.do({
+      api: API_NAME12,
+      operation: "customerIdentity.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+  /**
+   * Reruns a failed identity check. Only rerun a check whose `decision`
+   * was `"ERROR"` — this indicates a transient downstream provider
+   * issue. Do not rerun a check whose `decision` was `"FAIL"`;
+   * resubmitting returns the same `"FAIL"` result again.
+   */
+  async rerun(profileId, signal) {
+    const url = `${this.cfg.customerIdentificationUrl()}/identityprofiles/${encodeURIComponent(profileId)}/rerunfailedchecks`;
+    return this.transport.do({
+      api: API_NAME12,
+      operation: "customerIdentity.rerun",
+      method: "POST",
+      url,
+      body: {},
+      signal
+    });
+  }
+};
+
+// src/resources/bank-account-validation.ts
+var BankAccountValidationResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /**
+   * Starts a bank account verification session. Redirect the customer to
+   * {@link bankVerificationRedirectUrl} to complete the flow; there is no
+   * synchronous result.
+   */
+  async create(accountId, req, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.bankAccountValidatorUrl()}/accounts/${encodeURIComponent(resolvedAccountId)}/verifications`;
+    return this.transport.do({
+      api: "bank_account_validation",
+      operation: "bankAccountValidation.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /**
+   * Looks up a bank account verification by ID. Returns validated
+   * account details and a single-use payment token once the customer has
+   * completed the redirect flow.
+   */
+  async get(verificationId, signal) {
+    const url = `${this.cfg.bankAccountValidatorUrl()}/verifications/${encodeURIComponent(verificationId)}`;
+    return this.transport.do({
+      api: "bank_account_validation",
+      operation: "bankAccountValidation.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+};
+var InteracVerificationResource = class {
+  constructor(cfg, transport) {
+    this.cfg = cfg;
+    this.transport = transport;
+  }
+  cfg;
+  transport;
+  /** Starts an Interac AML Assist verification session. */
+  async create(accountId, req, signal) {
+    const resolvedAccountId = this.cfg.resolveAccountId(accountId);
+    const url = `${this.cfg.bankAccountValidatorUrl()}/verifiedme/accounts/${encodeURIComponent(resolvedAccountId)}/verifications`;
+    return this.transport.do({
+      api: "interac_verification",
+      operation: "interacVerification.create",
+      method: "POST",
+      url,
+      body: req,
+      signal
+    });
+  }
+  /**
+   * Fetches the user's verified information once they have completed the
+   * redirect flow on Interac's bank page.
+   */
+  async get(verificationId, signal) {
+    const url = `${this.cfg.bankAccountValidatorUrl()}/verifiedme/verifications/${encodeURIComponent(verificationId)}`;
+    return this.transport.do({
+      api: "interac_verification",
+      operation: "interacVerification.get",
+      method: "GET",
+      url,
+      signal
+    });
+  }
+};
+function bankVerificationRedirectUrl(verification) {
+  return findLinkByRel(verification.links, "redirect_bank_validation");
+}
+
+// src/core/webhook-crypto.ts
+var encoder = new TextEncoder();
+function isNodeRuntime() {
+  return typeof process !== "undefined" && typeof process.versions === "object" && typeof process.versions.node === "string";
+}
+async function hmacSha256Base64Node(key, data) {
+  const nodeCrypto = await import('crypto');
+  const mac = nodeCrypto.createHmac("sha256", key);
+  mac.update(data);
+  return mac.digest("base64");
+}
+async function hmacSha256Base64WebCrypto(key, data) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error(
+      "No HMAC implementation available: neither node:crypto nor globalThis.crypto.subtle is present in this runtime."
+    );
+  }
+  const cryptoKey = await subtle.importKey(
+    "raw",
+    encoder.encode(key),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await subtle.sign("HMAC", cryptoKey, data);
+  return bufferToBase64(new Uint8Array(signature));
+}
+function bufferToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+async function hmacSha256Base64(key, data) {
+  const bytes = typeof data === "string" ? encoder.encode(data) : data;
+  return isNodeRuntime() ? hmacSha256Base64Node(key, bytes) : hmacSha256Base64WebCrypto(key, bytes);
+}
+async function timingSafeStringEqual(a, b) {
+  if (isNodeRuntime()) {
+    const nodeCrypto = await import('crypto');
+    const bufA = Buffer.from(a, "utf-8");
+    const bufB = Buffer.from(b, "utf-8");
+    if (bufA.length !== bufB.length) {
+      nodeCrypto.timingSafeEqual(bufA, bufA);
+      return false;
+    }
+    return nodeCrypto.timingSafeEqual(bufA, bufB);
+  }
+  const bytesA = encoder.encode(a);
+  const bytesB = encoder.encode(b);
+  const length = Math.max(bytesA.length, bytesB.length);
+  let mismatch = bytesA.length === bytesB.length ? 0 : 1;
+  for (let i = 0; i < length; i++) {
+    const byteA = bytesA[i] ?? 0;
+    const byteB = bytesB[i] ?? 0;
+    mismatch |= byteA ^ byteB;
+  }
+  return mismatch === 0;
+}
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  /**
+   * Verifies the HMAC-SHA256 signature of `rawBody` against `signature`
+   * using `hmacKey`, then decodes the payload into a
+   * {@link PaysafeWebhookEvent}.
+   *
+   * @param rawBody - The exact, unmodified request body bytes/text as received.
+   * @param signature - The value of the `Signature` HTTP header.
+   * @param hmacKey - The merchant's webhook HMAC key from the Paysafe portal.
+   *
+   * Verification uses a constant-time comparison to prevent timing
+   * attacks.
+   */
+  async verifyAndParse(rawBody, signature, hmacKey) {
+    await this.verifySignature(rawBody, signature, hmacKey);
+    return this.parse(rawBody);
+  }
+  /**
+   * Verifies the webhook signature without parsing the body. Resolves on
+   * success, or throws a {@link PaysafeError} with
+   * `kind === "webhook_signature_mismatch"` on failure.
+   */
+  async verifySignature(rawBody, signature, hmacKey) {
+    const expected = await hmacSha256Base64(hmacKey, rawBody);
+    const matches = await timingSafeStringEqual(expected, signature);
+    if (!matches) {
+      throw PaysafeError.webhookMismatch();
+    }
+  }
+  /**
+   * Decodes a webhook body that has already been verified (e.g. by a
+   * signature-checking middleware) into a {@link PaysafeWebhookEvent}.
+   */
+  parse(rawBody) {
+    const text = typeof rawBody === "string" ? rawBody : new TextDecoder().decode(rawBody);
+    try {
+      return JSON.parse(text);
+    } catch (cause) {
+      throw PaysafeError.decodeError(cause);
+    }
+  }
+  /**
+   * Parses an already-decoded object into a {@link PaysafeWebhookEvent},
+   * useful when the caller's web framework has already deserialized the
+   * JSON body.
+   */
+  parseObject(obj) {
+    return obj;
+  }
+};
+function webhookTopic(event) {
+  const name = event.eventName;
+  if (name.startsWith("PAYMENT_HANDLE_")) return "payment_handle";
+  if (name.startsWith("PAYMENT_")) return "payment";
+  if (name.startsWith("SETTLEMENT_")) return "settlement";
+  if (name.startsWith("REFUND_")) return "refund";
+  if (name.startsWith("STANDALONE_CREDIT_") || name.startsWith("ORIGINAL_CREDIT_")) return "payout";
+  if (name.startsWith("SUBSCRIPTION_")) return "subscription";
+  if (name.startsWith("ACCOUNT_UPDATER_")) return "account_updater";
+  return "unknown";
+}
+var PAYMENT_HANDLE_STATUS_BY_EVENT = {
+  PAYMENT_HANDLE_INITIATED: "INITIATED",
+  PAYMENT_HANDLE_PROCESSING: "PROCESSING",
+  PAYMENT_HANDLE_PAYABLE: "PAYABLE",
+  PAYMENT_HANDLE_COMPLETED: "COMPLETED",
+  PAYMENT_HANDLE_FAILED: "FAILED",
+  PAYMENT_HANDLE_EXPIRED: "EXPIRED",
+  PAYMENT_HANDLE_CANCELLED: "CANCELLED"
+};
+function webhookPaymentHandleStatus(event) {
+  return PAYMENT_HANDLE_STATUS_BY_EVENT[event.eventName];
+}
+
+// src/client.ts
+var PaysafeClient = class _PaysafeClient {
+  cfg;
+  // Payments API
+  paymentHandles;
+  payments;
+  settlements;
+  refunds;
+  payouts;
+  verifications;
+  customers;
+  // Payment Scheduler API
+  plans;
+  subscriptions;
+  // Applications (Onboarding) API
+  applications;
+  // Value Added Services
+  fxRates;
+  customerIdentity;
+  bankAccountValidation;
+  interacVerification;
+  // Webhooks
+  webhooks;
+  constructor(options, telemetryHook) {
+    this.cfg = new ResolvedConfig(options);
+    const limiter = new RateLimiter();
+    const transport = new HttpTransport(this.cfg, limiter, telemetryHook);
+    this.paymentHandles = new PaymentHandlesResource(this.cfg, transport);
+    this.payments = new PaymentsResource(this.cfg, transport);
+    this.settlements = new SettlementsResource(this.cfg, transport);
+    this.refunds = new RefundsResource(this.cfg, transport);
+    this.payouts = new PayoutsResource(this.cfg, transport);
+    this.verifications = new VerificationsResource(this.cfg, transport);
+    this.customers = new CustomersResource(this.cfg, transport);
+    this.plans = new PlansResource(this.cfg, transport);
+    this.subscriptions = new SubscriptionsResource(this.cfg, transport);
+    this.applications = new ApplicationsResource(this.cfg, transport);
+    this.fxRates = new FxRatesResource(this.cfg, transport);
+    this.customerIdentity = new CustomerIdentityResource(this.cfg, transport);
+    this.bankAccountValidation = new BankAccountValidationResource(this.cfg, transport);
+    this.interacVerification = new InteracVerificationResource(this.cfg, transport);
+    this.webhooks = new WebhooksResource();
+  }
+  /**
+   * Builds a `PaysafeClient` from `PAYSAFE_USERNAME`, `PAYSAFE_PASSWORD`,
+   * `PAYSAFE_ENVIRONMENT`, and `PAYSAFE_ACCOUNT_ID` environment variables
+   * (Node.js only), merged with any additional `overrides` (last-wins).
+   */
+  static fromEnv(overrides = {}, telemetryHook) {
+    return new _PaysafeClient(configFromEnv(overrides), telemetryHook);
+  }
+  /** The client's configured default account ID, if set. */
+  get accountId() {
+    return this.cfg.accountId;
+  }
+  /** The client's configured environment (`"test"` or `"production"`). */
+  get environment() {
+    return this.cfg.environment;
+  }
+  /** The resolved base URL the client sends requests to. */
+  get baseUrl() {
+    return this.cfg.baseUrl();
+  }
+};
+
+exports.ApplicationsResource = ApplicationsResource;
+exports.BankAccountValidationResource = BankAccountValidationResource;
+exports.CustomerIdentityResource = CustomerIdentityResource;
+exports.CustomersResource = CustomersResource;
+exports.FxRatesResource = FxRatesResource;
+exports.InteracVerificationResource = InteracVerificationResource;
+exports.PaymentHandlesResource = PaymentHandlesResource;
+exports.PaymentsResource = PaymentsResource;
+exports.PayoutsResource = PayoutsResource;
+exports.PaysafeClient = PaysafeClient;
+exports.PaysafeError = PaysafeError;
+exports.PlansResource = PlansResource;
+exports.RefundsResource = RefundsResource;
+exports.SettlementsResource = SettlementsResource;
+exports.SubscriptionsResource = SubscriptionsResource;
+exports.VerificationsResource = VerificationsResource;
+exports.WebhooksResource = WebhooksResource;
+exports.bankVerificationRedirectUrl = bankVerificationRedirectUrl;
+exports.findLinkByRel = findLinkByRel;
+exports.paymentHandleRedirectUrl = paymentHandleRedirectUrl;
+exports.paymentHandleRequiresAction = paymentHandleRequiresAction;
+exports.webhookPaymentHandleStatus = webhookPaymentHandleStatus;
+exports.webhookTopic = webhookTopic;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map