@havenpay/server 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1083 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Havenpay: () => Havenpay,
+  HavenpayApiError: () => HavenpayApiError,
+  HavenpayTimeoutError: () => HavenpayTimeoutError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var HavenpayApiError = class extends Error {
+  constructor(options) {
+    super(`Havenpay API Error: ${options.status} ${options.body}`);
+    this.name = "HavenpayApiError";
+    this.body = options.body;
+    this.status = options.status;
+    if (options.requestId)
+      this.requestId = options.requestId;
+    if (options.error) {
+      this.error = options.error;
+      if (options.error.code)
+        this.code = options.error.code;
+      if (options.error.type)
+        this.type = options.error.type;
+    }
+  }
+};
+var HavenpayTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Havenpay request timed out after ${timeoutMs}ms`);
+    this.name = "HavenpayTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+function parseHavenpayApiErrorDetails(parsed) {
+  if (!isRecord(parsed) || !isRecord(parsed.error))
+    return void 0;
+  const result = {};
+  if (typeof parsed.error.code === "string")
+    result.code = parsed.error.code;
+  if (typeof parsed.error.message === "string")
+    result.message = parsed.error.message;
+  if (typeof parsed.error.request_id === "string")
+    result.requestId = parsed.error.request_id;
+  if (typeof parsed.error.type === "string")
+    result.type = parsed.error.type;
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/resources/Accounts.ts
+var import_api_v1 = require("@havenpay/core/api-v1");
+
+// src/resources/http.ts
+function baseUrl(config) {
+  const value = config.baseUrl || "https://pay.7haven.online/api";
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function authHeaders(config) {
+  return {
+    ...apiVersionHeaders(config),
+    "X-API-Key": config.secretKey
+  };
+}
+function bearerHeaders(config) {
+  return {
+    ...apiVersionHeaders(config),
+    Authorization: `Bearer ${config.secretKey}`
+  };
+}
+function jsonHeaders(config, extraHeaders = {}) {
+  return {
+    "Content-Type": "application/json",
+    ...authHeaders(config),
+    ...extraHeaders
+  };
+}
+function pathWithParams(path, params) {
+  return path.replace(/\{([^}]+)\}/g, (_match, key) => encodeURIComponent(params[key] ?? ""));
+}
+function withQuery(path, params) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0)
+      query.set(key, String(value));
+  }
+  const encoded = query.toString();
+  return encoded ? `${path}?${encoded}` : path;
+}
+async function request(config, input, init, options = {}) {
+  const retry = retryOptions(config);
+  const canRetry = canRetryRequest(init);
+  const eventBase = requestEventBase(input, init, options);
+  let attempt = 1;
+  while (true) {
+    const timeout = timeoutRequestInit(config, init);
+    emitRequestEvent(config, { ...eventBase, attempt, type: "request_start" });
+    try {
+      const response = await fetch(input, timeout.init);
+      if (shouldRetryResponse(response, retry.maxAttempts, attempt, canRetry)) {
+        emitRequestEvent(config, {
+          ...eventBase,
+          attempt,
+          errorKind: "api_error",
+          requestId: response.headers.get("x-request-id") ?? void 0,
+          status: response.status,
+          type: "request_retry"
+        });
+      } else {
+        emitRequestEvent(config, finalResponseEvent(eventBase, response, attempt));
+        return response;
+      }
+    } catch (error) {
+      if (timeout.didTimeout()) {
+        emitRequestEvent(config, {
+          ...eventBase,
+          attempt,
+          errorKind: "timeout",
+          type: "request_error"
+        });
+        throw new HavenpayTimeoutError(timeout.timeoutMs);
+      }
+      if (shouldRetryError(retry.maxAttempts, attempt, canRetry)) {
+        emitRequestEvent(config, {
+          ...eventBase,
+          attempt,
+          errorKind: "network_error",
+          type: "request_retry"
+        });
+      } else {
+        emitRequestEvent(config, {
+          ...eventBase,
+          attempt,
+          errorKind: "network_error",
+          type: "request_error"
+        });
+        throw error;
+      }
+    } finally {
+      timeout.cleanup();
+    }
+    await retry.sleep(retryDelayMs(retry, attempt));
+    attempt += 1;
+  }
+}
+async function parseJsonObjectResponse(response) {
+  const requestId = response.headers.get("x-request-id") ?? void 0;
+  const body = await response.text();
+  if (!response.ok) {
+    const parsed2 = parseJsonBody(body);
+    const error = parseHavenpayApiErrorDetails(parsed2);
+    throw new HavenpayApiError({
+      body,
+      error,
+      requestId: requestId ?? error?.requestId,
+      status: response.status
+    });
+  }
+  const parsed = JSON.parse(body || "{}");
+  return {
+    parsed: isRecord2(parsed) ? parsed : {},
+    requestId
+  };
+}
+async function parseJsonListResponse(response, mapItem) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  const data = Array.isArray(parsed.data) ? parsed.data.filter(isRecord2).map((item) => mapItem(item)) : [];
+  const result = {
+    data,
+    hasMore: Boolean(parsed.has_more),
+    requestId
+  };
+  if (typeof parsed.next_cursor === "string")
+    result.nextCursor = parsed.next_cursor;
+  return result;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function apiVersionHeaders(config) {
+  return config.apiVersion ? { "X-Haven-API-Version": config.apiVersion } : {};
+}
+function retryOptions(config) {
+  return {
+    initialDelayMs: Math.max(0, config.retry?.initialDelayMs ?? 100),
+    maxAttempts: Math.max(1, Math.floor(config.retry?.maxAttempts ?? (config.retry ? 3 : 1))),
+    maxDelayMs: Math.max(0, config.retry?.maxDelayMs ?? 2e3),
+    sleep: config.retry?.sleep ?? defaultSleep
+  };
+}
+function canRetryRequest(init) {
+  const method = String(init.method ?? "GET").toUpperCase();
+  if (method === "GET" || method === "HEAD")
+    return true;
+  return Boolean(new Headers(init.headers).get("idempotency-key"));
+}
+function shouldRetryResponse(response, maxAttempts, attempt, canRetry) {
+  return canRetry && attempt < maxAttempts && response.status >= 500 && response.status <= 599;
+}
+function shouldRetryError(maxAttempts, attempt, canRetry) {
+  return canRetry && attempt < maxAttempts;
+}
+function retryDelayMs(retry, attempt) {
+  const delay = retry.initialDelayMs * 2 ** Math.max(0, attempt - 1);
+  return Math.min(delay, retry.maxDelayMs);
+}
+async function defaultSleep(delayMs) {
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function timeoutRequestInit(config, init) {
+  const timeoutMs = timeoutMsOrZero(config);
+  if (timeoutMs === 0) {
+    return {
+      cleanup: () => {
+      },
+      didTimeout: () => false,
+      init,
+      timeoutMs
+    };
+  }
+  const controller = new AbortController();
+  let timedOut = false;
+  let callerAbortListener;
+  const timeoutId = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new HavenpayTimeoutError(timeoutMs));
+  }, timeoutMs);
+  if (init.signal) {
+    if (init.signal.aborted) {
+      clearTimeout(timeoutId);
+      controller.abort(init.signal.reason);
+    } else {
+      callerAbortListener = () => {
+        clearTimeout(timeoutId);
+        controller.abort(init.signal?.reason);
+      };
+      init.signal.addEventListener("abort", callerAbortListener, { once: true });
+    }
+  }
+  return {
+    cleanup: () => {
+      clearTimeout(timeoutId);
+      if (callerAbortListener)
+        init.signal?.removeEventListener("abort", callerAbortListener);
+    },
+    didTimeout: () => timedOut,
+    init: {
+      ...init,
+      signal: controller.signal
+    },
+    timeoutMs
+  };
+}
+function timeoutMsOrZero(config) {
+  if (config.timeoutMs === void 0)
+    return 0;
+  return Math.max(0, Math.floor(config.timeoutMs));
+}
+function requestEventBase(input, init, options) {
+  const base = {
+    method: String(init.method ?? "GET").toUpperCase(),
+    path: requestPath(input)
+  };
+  if (options.operationName)
+    base.operationName = options.operationName;
+  return base;
+}
+function requestPath(input) {
+  if (typeof input === "string") {
+    try {
+      return new URL(input).pathname;
+    } catch {
+      return input.split("?")[0] ?? input;
+    }
+  }
+  if (input instanceof URL)
+    return input.pathname;
+  return new URL(input.url).pathname;
+}
+function finalResponseEvent(base, response, attempt) {
+  const requestId = response.headers.get("x-request-id") ?? void 0;
+  if (response.ok) {
+    return {
+      ...base,
+      attempt,
+      requestId,
+      status: response.status,
+      type: "request_success"
+    };
+  }
+  return {
+    ...base,
+    attempt,
+    errorKind: "api_error",
+    requestId,
+    status: response.status,
+    type: "request_error"
+  };
+}
+function emitRequestEvent(config, event) {
+  try {
+    config.onRequestEvent?.(event);
+  } catch {
+  }
+}
+function parseJsonBody(body) {
+  try {
+    return JSON.parse(body || "{}");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/resources/Accounts.ts
+var Accounts = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    const operation = import_api_v1.API_V1_OPERATIONS.createAccount;
+    const response = await request(this.config, `${baseUrl(this.config)}${operation.path}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify(accountPayload(params))
+    }, {
+      operationName: "createAccount"
+    });
+    return parseAccountResponse(response);
+  }
+  async list(params = {}) {
+    const operation = import_api_v1.API_V1_OPERATIONS.listAccounts;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(operation.path, {
+      limit: params.limit,
+      starting_after: params.startingAfter
+    })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "listAccounts"
+    });
+    return parseAccountListResponse(response);
+  }
+  async update(id, params) {
+    const operation = import_api_v1.API_V1_OPERATIONS.updateAccount;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify(accountPayload(params))
+    }, {
+      operationName: "updateAccount"
+    });
+    return parseAccountResponse(response);
+  }
+};
+function accountPayload(params) {
+  return {
+    ...params.capabilities !== void 0 ? { capabilities: params.capabilities } : {},
+    ...params.displayName !== void 0 ? { display_name: params.displayName } : {},
+    ...params.email !== void 0 ? { email: params.email } : {},
+    ..."livemode" in params && params.livemode !== void 0 ? { livemode: params.livemode } : {},
+    ...params.metadata !== void 0 ? { metadata: params.metadata } : {},
+    ..."status" in params && params.status !== void 0 ? { status: params.status } : {}
+  };
+}
+async function parseAccountResponse(response) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  return toAccountResponse(parsed, requestId);
+}
+async function parseAccountListResponse(response) {
+  return parseJsonListResponse(response, toAccountResponse);
+}
+function toAccountResponse(parsed, requestId) {
+  return {
+    accountRole: String(parsed.account_role ?? "connected"),
+    capabilities: normalizeAccountCapabilities(parsed.capabilities),
+    createdAt: String(parsed.created_at ?? ""),
+    displayName: String(parsed.display_name ?? ""),
+    email: String(parsed.email ?? ""),
+    id: String(parsed.id ?? ""),
+    livemode: Boolean(parsed.livemode),
+    metadata: isRecord2(parsed.metadata) ? parsed.metadata : {},
+    ownerAccountId: typeof parsed.owner_account_id === "string" ? parsed.owner_account_id : null,
+    requestId,
+    status: String(parsed.status ?? "draft"),
+    updatedAt: String(parsed.updated_at ?? "")
+  };
+}
+function normalizeAccountCapabilities(value) {
+  const fallback = {
+    card_payments: false,
+    mobile_money_payments: false,
+    payouts: false,
+    refunds: false,
+    test_mode: true,
+    webhooks: false
+  };
+  if (!isRecord2(value))
+    return fallback;
+  return {
+    card_payments: typeof value.card_payments === "boolean" ? value.card_payments : fallback.card_payments,
+    mobile_money_payments: typeof value.mobile_money_payments === "boolean" ? value.mobile_money_payments : fallback.mobile_money_payments,
+    payouts: typeof value.payouts === "boolean" ? value.payouts : fallback.payouts,
+    refunds: typeof value.refunds === "boolean" ? value.refunds : fallback.refunds,
+    test_mode: typeof value.test_mode === "boolean" ? value.test_mode : fallback.test_mode,
+    webhooks: typeof value.webhooks === "boolean" ? value.webhooks : fallback.webhooks
+  };
+}
+
+// src/resources/ApiKeys.ts
+var import_api_v12 = require("@havenpay/core/api-v1");
+var ApiKeys = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    const operation = import_api_v12.API_V1_OPERATIONS.createApiKey;
+    const response = await request(this.config, `${baseUrl(this.config)}${operation.path}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify({
+        display_name: params.displayName,
+        ...params.scopes ? { scopes: params.scopes } : {}
+      })
+    }, {
+      operationName: "createApiKey"
+    });
+    return parseApiKeyResponse(response);
+  }
+  async list(params = {}) {
+    const operation = import_api_v12.API_V1_OPERATIONS.listApiKeys;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(operation.path, {
+      account_id: params.accountId,
+      limit: params.limit,
+      starting_after: params.startingAfter
+    })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "listApiKeys"
+    });
+    return parseApiKeyListResponse(response);
+  }
+  async revoke(id) {
+    const operation = import_api_v12.API_V1_OPERATIONS.revokeApiKey;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "revokeApiKey"
+    });
+    return parseApiKeyResponse(response);
+  }
+};
+async function parseApiKeyResponse(response) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  return toApiKeyResponse(parsed, requestId);
+}
+async function parseApiKeyListResponse(response) {
+  return parseJsonListResponse(response, toApiKeyResponse);
+}
+function toApiKeyResponse(parsed, requestId) {
+  return {
+    accountId: String(parsed.account_id ?? ""),
+    createdAt: String(parsed.created_at ?? ""),
+    displayName: String(parsed.display_name ?? ""),
+    environment: String(parsed.environment ?? "test"),
+    expiresAt: typeof parsed.expires_at === "string" ? parsed.expires_at : null,
+    id: String(parsed.id ?? ""),
+    lastUsedAt: typeof parsed.last_used_at === "string" ? parsed.last_used_at : null,
+    prefix: String(parsed.prefix ?? ""),
+    requestId,
+    revokedAt: typeof parsed.revoked_at === "string" ? parsed.revoked_at : null,
+    scopes: Array.isArray(parsed.scopes) ? parsed.scopes.filter((scope) => typeof scope === "string") : [],
+    secretKey: typeof parsed.secret_key === "string" ? parsed.secret_key : void 0
+  };
+}
+
+// src/resources/BalanceTransactions.ts
+var import_api_v13 = require("@havenpay/core/api-v1");
+var BalanceTransactions = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async list(params = {}) {
+    const operation = import_api_v13.API_V1_OPERATIONS.listBalanceTransactions;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(operation.path, {
+      currency: params.currency,
+      limit: params.limit,
+      payment_intent_id: params.paymentIntentId,
+      project_id: params.projectId,
+      starting_after: params.startingAfter
+    })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "listBalanceTransactions"
+    });
+    return parseBalanceTransactionListResponse(response);
+  }
+};
+async function parseBalanceTransactionListResponse(response) {
+  return parseJsonListResponse(response, toBalanceTransactionResponse);
+}
+function toBalanceTransactionResponse(parsed) {
+  return {
+    accountId: String(parsed.account_id ?? ""),
+    amount: Number(parsed.amount ?? 0),
+    balanceAfter: Number(parsed.balance_after ?? 0),
+    balanceBefore: Number(parsed.balance_before ?? 0),
+    createdAt: String(parsed.created_at ?? ""),
+    currency: String(parsed.currency ?? "usd"),
+    description: String(parsed.description ?? ""),
+    id: String(parsed.id ?? ""),
+    metadata: isRecord2(parsed.metadata) ? parsed.metadata : {},
+    paymentIntentId: typeof parsed.payment_intent_id === "string" ? parsed.payment_intent_id : null,
+    projectId: typeof parsed.project_id === "string" ? parsed.project_id : null,
+    type: String(parsed.type ?? "payment")
+  };
+}
+
+// src/resources/Events.ts
+var import_api_v14 = require("@havenpay/core/api-v1");
+var Events = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async list(params = {}) {
+    const operation = import_api_v14.API_V1_OPERATIONS.listEvents;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(operation.path, {
+      project_id: params.projectId,
+      limit: params.limit,
+      starting_after: params.startingAfter
+    })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "listEvents"
+    });
+    return parseEventListResponse(response);
+  }
+  async replay(id) {
+    const operation = import_api_v14.API_V1_OPERATIONS.replayEvent;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "replayEvent"
+    });
+    return parseReplayEventResponse(response);
+  }
+};
+async function parseEventListResponse(response) {
+  return parseJsonListResponse(response, toEventResponse);
+}
+async function parseReplayEventResponse(response) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  return {
+    id: String(parsed.id ?? ""),
+    requestId,
+    status: String(parsed.status ?? "pending")
+  };
+}
+function toEventResponse(parsed) {
+  return {
+    accountId: String(parsed.account_id ?? ""),
+    apiVersion: String(parsed.api_version ?? ""),
+    created: String(parsed.created ?? ""),
+    data: isRecord2(parsed.data) ? parsed.data : {},
+    id: String(parsed.id ?? ""),
+    livemode: Boolean(parsed.livemode),
+    objectId: String(parsed.object_id ?? ""),
+    pendingWebhookEndpoints: stringArray(parsed.pending_webhook_endpoints),
+    projectId: String(parsed.project_id ?? ""),
+    status: String(parsed.status ?? "pending"),
+    type: String(parsed.type ?? "payment_intent.created")
+  };
+}
+
+// src/resources/PaymentIntents.ts
+var import_node_crypto = require("crypto");
+var import_api_v15 = require("@havenpay/core/api-v1");
+var PaymentIntents = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    const operation = import_api_v15.API_V1_OPERATIONS.createPaymentIntent;
+    const url = `${baseUrl(this.config)}${operation.path}`;
+    const idempotencyKey = params.idempotencyKey || (0, import_node_crypto.randomUUID)();
+    const headers = {
+      ...bearerHeaders(this.config),
+      "Content-Type": "application/json",
+      "Idempotency-Key": idempotencyKey
+    };
+    const response = await request(this.config, url, {
+      method: operation.method,
+      headers,
+      body: JSON.stringify({
+        amount: params.amount,
+        currency: params.currency,
+        customer: params.customer,
+        idempotency_key: idempotencyKey,
+        metadata: params.metadata,
+        mobile_money: params.mobileMoney,
+        payment_method_type: "mobile_money",
+        project_id: params.projectId
+      })
+    }, {
+      operationName: "createPaymentIntent"
+    });
+    return parsePaymentIntentResponse(response);
+  }
+  async retrieve(id) {
+    const operation = import_api_v15.API_V1_OPERATIONS.retrievePaymentIntent;
+    const url = `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`;
+    const response = await request(this.config, url, {
+      method: operation.method,
+      headers: bearerHeaders(this.config)
+    }, {
+      operationName: "retrievePaymentIntent"
+    });
+    return parsePaymentIntentResponse(response);
+  }
+};
+async function parsePaymentIntentResponse(response) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  return {
+    amount: Number(parsed.amount ?? 0),
+    clientSecret: String(parsed.client_secret ?? parsed.clientSecret ?? ""),
+    currency: String(parsed.currency ?? "usd"),
+    customer: isRecord2(parsed.customer) ? parsed.customer : void 0,
+    id: String(parsed.id),
+    nextAction: isRecord2(parsed.next_action) ? parsed.next_action : isRecord2(parsed.nextAction) ? parsed.nextAction : void 0,
+    requestId,
+    status: String(parsed.status)
+  };
+}
+
+// src/resources/Projects.ts
+var import_api_v16 = require("@havenpay/core/api-v1");
+var Projects = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    const operation = import_api_v16.API_V1_OPERATIONS.createProject;
+    const response = await request(this.config, `${baseUrl(this.config)}${operation.path}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify(projectPayload(params))
+    }, {
+      operationName: "createProject"
+    });
+    return parseProjectResponse(response);
+  }
+  async list(params = {}) {
+    const operation = import_api_v16.API_V1_OPERATIONS.listProjects;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(operation.path, {
+      limit: params.limit,
+      starting_after: params.startingAfter
+    })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "listProjects"
+    });
+    return parseProjectListResponse(response);
+  }
+  async update(id, params) {
+    const operation = import_api_v16.API_V1_OPERATIONS.updateProject;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { project_id: id })}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify(projectPayload(params))
+    }, {
+      operationName: "updateProject"
+    });
+    return parseProjectResponse(response);
+  }
+  async archive(id) {
+    const operation = import_api_v16.API_V1_OPERATIONS.archiveProject;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { project_id: id })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "archiveProject"
+    });
+    return parseProjectResponse(response);
+  }
+  async getConfig(id) {
+    const operation = import_api_v16.API_V1_OPERATIONS.getProjectConfig;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { project_id: id })}`, {
+      method: operation.method
+    }, {
+      operationName: "getProjectConfig"
+    });
+    return parseProjectResponse(response);
+  }
+};
+function projectPayload(params) {
+  return {
+    ...params.allowedBundleIds !== void 0 ? { allowed_bundle_ids: params.allowedBundleIds } : {},
+    ...params.allowedCurrencies !== void 0 ? { allowed_currencies: params.allowedCurrencies } : {},
+    ...params.allowedOrigins !== void 0 ? { allowed_origins: params.allowedOrigins } : {},
+    ...params.allowedPaymentMethods !== void 0 ? { allowed_payment_methods: params.allowedPaymentMethods } : {},
+    ...params.allowedReturnUrls !== void 0 ? { allowed_return_urls: params.allowedReturnUrls } : {},
+    ...params.appearance !== void 0 ? { appearance: params.appearance } : {},
+    ...params.displayName !== void 0 ? { display_name: params.displayName } : {},
+    ..."environment" in params && params.environment !== void 0 ? { environment: params.environment } : {},
+    ...params.rateLimitProfile !== void 0 ? { rate_limit_profile: params.rateLimitProfile } : {},
+    ..."status" in params && params.status !== void 0 ? { status: params.status } : {}
+  };
+}
+async function parseProjectResponse(response) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  return toProjectResponse(parsed, requestId);
+}
+async function parseProjectListResponse(response) {
+  return parseJsonListResponse(response, toProjectResponse);
+}
+function toProjectResponse(parsed, requestId) {
+  return {
+    accountId: typeof parsed.account_id === "string" ? parsed.account_id : void 0,
+    allowedBundleIds: stringArray(parsed.allowed_bundle_ids),
+    allowedCurrencies: stringArray(parsed.allowed_currencies),
+    allowedOrigins: stringArray(parsed.allowed_origins),
+    allowedPaymentMethods: stringArray(parsed.allowed_payment_methods),
+    allowedReturnUrls: stringArray(parsed.allowed_return_urls),
+    appearance: isRecord2(parsed.appearance) ? parsed.appearance : {},
+    archived: typeof parsed.archived === "boolean" ? parsed.archived : void 0,
+    createdAt: typeof parsed.created_at === "string" ? parsed.created_at : void 0,
+    deleted: typeof parsed.deleted === "boolean" ? parsed.deleted : void 0,
+    displayName: String(parsed.display_name ?? ""),
+    environment: String(parsed.environment ?? "test"),
+    id: String(parsed.project_id ?? ""),
+    paymentHistoryCount: typeof parsed.payment_history_count === "number" ? parsed.payment_history_count : void 0,
+    rateLimitProfile: typeof parsed.rate_limit_profile === "string" ? parsed.rate_limit_profile : void 0,
+    requestId,
+    status: String(parsed.status ?? "active"),
+    updatedAt: typeof parsed.updated_at === "string" ? parsed.updated_at : void 0
+  };
+}
+
+// src/resources/ProviderAccounts.ts
+var import_api_v17 = require("@havenpay/core/api-v1");
+var ProviderAccounts = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    const operation = import_api_v17.API_V1_OPERATIONS.createProviderAccount;
+    const response = await request(this.config, `${baseUrl(this.config)}${operation.path}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify({
+        encrypted_credential_ref: params.encryptedCredentialRef,
+        key_fingerprint: params.keyFingerprint,
+        ...params.metadata ? { metadata: params.metadata } : {},
+        project_id: params.projectId,
+        provider: params.provider
+      })
+    }, {
+      operationName: "createProviderAccount"
+    });
+    return parseProviderAccountResponse(response);
+  }
+  async list(params = {}) {
+    const operation = import_api_v17.API_V1_OPERATIONS.listProviderAccounts;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(operation.path, {
+      project_id: params.projectId,
+      limit: params.limit,
+      starting_after: params.startingAfter
+    })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "listProviderAccounts"
+    });
+    return parseProviderAccountListResponse(response);
+  }
+  async rotate(id, params) {
+    const operation = import_api_v17.API_V1_OPERATIONS.rotateProviderAccount;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify({
+        encrypted_credential_ref: params.encryptedCredentialRef,
+        key_fingerprint: params.keyFingerprint,
+        ...params.metadata ? { metadata: params.metadata } : {}
+      })
+    }, {
+      operationName: "rotateProviderAccount"
+    });
+    return parseProviderAccountResponse(response);
+  }
+  async revoke(id) {
+    const operation = import_api_v17.API_V1_OPERATIONS.revokeProviderAccount;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "revokeProviderAccount"
+    });
+    return parseProviderAccountResponse(response);
+  }
+};
+async function parseProviderAccountResponse(response) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  return toProviderAccountResponse(parsed, requestId);
+}
+async function parseProviderAccountListResponse(response) {
+  return parseJsonListResponse(response, toProviderAccountResponse);
+}
+function toProviderAccountResponse(parsed, requestId) {
+  return {
+    accountId: String(parsed.account_id ?? ""),
+    createdAt: String(parsed.created_at ?? ""),
+    environment: String(parsed.environment ?? "test"),
+    id: String(parsed.id ?? ""),
+    keyFingerprint: String(parsed.key_fingerprint ?? ""),
+    metadata: isRecord2(parsed.metadata) ? parsed.metadata : {},
+    projectId: String(parsed.project_id ?? ""),
+    provider: String(parsed.provider ?? "fake"),
+    requestId,
+    revokedAt: typeof parsed.revoked_at === "string" ? parsed.revoked_at : null,
+    rotatedFrom: typeof parsed.rotated_from === "string" ? parsed.rotated_from : void 0,
+    status: String(parsed.status ?? "active"),
+    updatedAt: String(parsed.updated_at ?? "")
+  };
+}
+
+// src/resources/Refunds.ts
+var import_node_crypto2 = require("crypto");
+var import_api_v18 = require("@havenpay/core/api-v1");
+var Refunds = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    const operation = import_api_v18.API_V1_OPERATIONS.createRefund;
+    const idempotencyKey = params.idempotencyKey || (0, import_node_crypto2.randomUUID)();
+    const response = await request(this.config, `${baseUrl(this.config)}${operation.path}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config, { "Idempotency-Key": idempotencyKey }),
+      body: JSON.stringify({
+        ...params.amount !== void 0 ? { amount: params.amount } : {},
+        payment_intent_id: params.paymentIntentId,
+        ...params.reason ? { reason: params.reason } : {}
+      })
+    }, {
+      operationName: "createRefund"
+    });
+    return parseRefundResponse(response);
+  }
+  async retrieve(id, params = {}) {
+    const operation = import_api_v18.API_V1_OPERATIONS.retrieveRefund;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(
+      pathWithParams(operation.path, { id }),
+      {
+        project_id: params.projectId
+      }
+    )}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "retrieveRefund"
+    });
+    return parseRefundResponse(response);
+  }
+  async list(params = {}) {
+    const operation = import_api_v18.API_V1_OPERATIONS.listRefunds;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(operation.path, {
+      idempotency_key: params.idempotencyKey,
+      limit: params.limit,
+      project_id: params.projectId,
+      provider_refund_reference: params.providerRefundReference,
+      starting_after: params.startingAfter
+    })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "listRefunds"
+    });
+    return parseRefundListResponse(response);
+  }
+};
+async function parseRefundResponse(response) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  return toRefundResponse(parsed, requestId);
+}
+async function parseRefundListResponse(response) {
+  return parseJsonListResponse(response, toRefundResponse);
+}
+function toRefundResponse(parsed, requestId) {
+  return {
+    amount: Number(parsed.amount ?? 0),
+    currency: String(parsed.currency ?? "usd"),
+    id: String(parsed.id),
+    idempotencyKey: String(parsed.idempotency_key ?? ""),
+    ledgerEntryId: typeof parsed.ledger_entry_id === "string" ? parsed.ledger_entry_id : null,
+    paymentIntentId: String(parsed.payment_intent_id ?? ""),
+    projectId: String(parsed.project_id ?? ""),
+    provider: String(parsed.provider ?? "fake"),
+    providerErrorCode: typeof parsed.provider_error_code === "string" ? parsed.provider_error_code : null,
+    providerExecution: parsed.provider_execution === "attempted" ? "attempted" : "disabled",
+    providerRefundReference: typeof parsed.provider_refund_reference === "string" ? parsed.provider_refund_reference : null,
+    reason: typeof parsed.reason === "string" ? parsed.reason : null,
+    requestId,
+    status: String(parsed.status ?? "pending_provider_execution")
+  };
+}
+
+// src/resources/WebhookEndpoints.ts
+var import_api_v19 = require("@havenpay/core/api-v1");
+var WebhookEndpoints = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    const operation = import_api_v19.API_V1_OPERATIONS.createWebhookEndpoint;
+    const response = await request(this.config, `${baseUrl(this.config)}${operation.path}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify(endpointPayload(params))
+    }, {
+      operationName: "createWebhookEndpoint"
+    });
+    return parseEndpointResponse(response);
+  }
+  async list(params = {}) {
+    const operation = import_api_v19.API_V1_OPERATIONS.listWebhookEndpoints;
+    const response = await request(this.config, `${baseUrl(this.config)}${withQuery(operation.path, {
+      account_id: params.accountId,
+      limit: params.limit,
+      starting_after: params.startingAfter
+    })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "listWebhookEndpoints"
+    });
+    return parseEndpointListResponse(response);
+  }
+  async update(id, params) {
+    const operation = import_api_v19.API_V1_OPERATIONS.updateWebhookEndpoint;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`, {
+      method: operation.method,
+      headers: jsonHeaders(this.config),
+      body: JSON.stringify(endpointPayload(params))
+    }, {
+      operationName: "updateWebhookEndpoint"
+    });
+    return parseEndpointResponse(response);
+  }
+  async rotateSecret(id) {
+    const operation = import_api_v19.API_V1_OPERATIONS.rotateWebhookEndpointSecret;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "rotateWebhookEndpointSecret"
+    });
+    return parseEndpointResponse(response);
+  }
+  async delete(id) {
+    const operation = import_api_v19.API_V1_OPERATIONS.deleteWebhookEndpoint;
+    const response = await request(this.config, `${baseUrl(this.config)}${pathWithParams(operation.path, { id })}`, {
+      method: operation.method,
+      headers: authHeaders(this.config)
+    }, {
+      operationName: "deleteWebhookEndpoint"
+    });
+    return parseEndpointResponse(response);
+  }
+};
+function endpointPayload(params) {
+  return {
+    ...params.apiVersion !== void 0 ? { api_version: params.apiVersion } : {},
+    ...params.description !== void 0 ? { description: params.description } : {},
+    ...params.enabledEvents !== void 0 ? { enabled_events: params.enabledEvents } : {},
+    ...params.status !== void 0 ? { status: params.status } : {},
+    ...params.url !== void 0 ? { url: params.url } : {}
+  };
+}
+async function parseEndpointResponse(response) {
+  const { parsed, requestId } = await parseJsonObjectResponse(response);
+  return toEndpointResponse(parsed, requestId);
+}
+async function parseEndpointListResponse(response) {
+  return parseJsonListResponse(response, toEndpointResponse);
+}
+function toEndpointResponse(parsed, requestId) {
+  return {
+    accountId: String(parsed.account_id ?? ""),
+    apiVersion: String(parsed.api_version ?? ""),
+    createdAt: String(parsed.created_at ?? ""),
+    deleted: typeof parsed.deleted === "boolean" ? parsed.deleted : void 0,
+    description: typeof parsed.description === "string" ? parsed.description : void 0,
+    enabledEvents: stringArray(parsed.enabled_events),
+    id: String(parsed.id ?? ""),
+    requestId,
+    signingSecret: typeof parsed.signing_secret === "string" ? parsed.signing_secret : void 0,
+    status: String(parsed.status ?? "enabled"),
+    updatedAt: String(parsed.updated_at ?? ""),
+    url: String(parsed.url ?? "")
+  };
+}
+
+// src/resources/Webhooks.ts
+var import_node_crypto3 = require("crypto");
+var Webhooks = class {
+  constructEvent(params) {
+    const parts = params.signature.split(",");
+    const timestamp = parts.find((p) => p.startsWith("t="))?.split("=")[1];
+    const signature = parts.find((p) => p.startsWith("v1="))?.split("=")[1];
+    if (!timestamp || !signature)
+      throw new Error("Invalid signature header format");
+    const timestampSeconds = Number.parseInt(timestamp, 10);
+    if (!Number.isFinite(timestampSeconds))
+      throw new Error("Invalid signature timestamp");
+    const toleranceSeconds = params.toleranceSeconds ?? 300;
+    const timeDiff = Math.abs(Date.now() / 1e3 - timestampSeconds);
+    if (timeDiff > toleranceSeconds)
+      throw new Error("Webhook timestamp is too old");
+    const signedPayload = `${timestamp}.${params.rawBody}`;
+    const expectedSignature = (0, import_node_crypto3.createHmac)("sha256", params.secret).update(signedPayload).digest("hex");
+    const actual = Buffer.from(signature, "hex");
+    const expected = Buffer.from(expectedSignature, "hex");
+    if (actual.length !== expected.length || !(0, import_node_crypto3.timingSafeEqual)(actual, expected))
+      throw new Error("Invalid webhook signature");
+    return JSON.parse(params.rawBody);
+  }
+};
+
+// src/Havenpay.ts
+var Havenpay = class {
+  constructor(config) {
+    this.config = config;
+    if (!config.secretKey) {
+      throw new Error("Havenpay: secretKey is required");
+    }
+    this.accounts = new Accounts(this.config);
+    this.apiKeys = new ApiKeys(this.config);
+    this.balanceTransactions = new BalanceTransactions(this.config);
+    this.events = new Events(this.config);
+    this.paymentIntents = new PaymentIntents(this.config);
+    this.projects = new Projects(this.config);
+    this.providerAccounts = new ProviderAccounts(this.config);
+    this.refunds = new Refunds(this.config);
+    this.webhookEndpoints = new WebhookEndpoints(this.config);
+    this.webhooks = new Webhooks();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Havenpay,
+  HavenpayApiError,
+  HavenpayTimeoutError
+});