@delopay/sdk 0.5.1 → 0.6.0

package/dist/chunk-LCF7ILAH.js

@@ -0,0 +1,2959 @@
+// src/error.ts
+var DelopayError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "DelopayError";
+    this.status = options.status;
+    this.code = options.code;
+    this.type = options.type;
+    if (options.requestId !== void 0) this.requestId = options.requestId;
+    if (options.rawBody !== void 0) this.rawBody = options.rawBody;
+  }
+};
+var DelopayAuthenticationError = class extends DelopayError {
+  constructor(message = "Invalid API key", options) {
+    super(message, {
+      status: 401,
+      // Default to the generic "invalid API key" code, but let callers pass
+      // through the server-reported code (e.g. `UR_05` for unverified-email
+      // 401s) so they can differentiate between auth failure reasons.
+      code: options?.code || "AUTH_01",
+      type: options?.type || "authentication_error",
+      requestId: options?.requestId,
+      rawBody: options?.rawBody
+    });
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "DelopayAuthenticationError";
+  }
+};
+
+// src/resources/apiKeys.ts
+var ApiKeys = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new API key for a merchant.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - Key creation parameters (name, expiry, etc.).
+   * @returns The newly created key including the plaintext secret (shown once only).
+   *
+   * @example
+   * ```typescript
+   * const { key_value } = await delopay.apiKeys.create('merch_123', { name: 'Production key' });
+   * ```
+   */
+  async create(merchantId, params) {
+    return this.request("POST", `/api_keys/${encodeURIComponent(merchantId)}`, { body: params });
+  }
+  /**
+   * Retrieve metadata about an API key (does not return the plaintext secret).
+   *
+   * @param merchantId - The merchant account ID.
+   * @param keyId - The API key ID.
+   * @returns The API key metadata.
+   */
+  async retrieve(merchantId, keyId) {
+    return this.request(
+      "GET",
+      `/api_keys/${encodeURIComponent(merchantId)}/${encodeURIComponent(keyId)}`
+    );
+  }
+  /**
+   * Update an API key's name or expiry.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param keyId - The API key ID to update.
+   * @param params - Fields to update.
+   * @returns The updated API key metadata.
+   */
+  async update(merchantId, keyId, params) {
+    return this.request(
+      "POST",
+      `/api_keys/${encodeURIComponent(merchantId)}/${encodeURIComponent(keyId)}`,
+      { body: params }
+    );
+  }
+  /**
+   * Revoke an API key, immediately invalidating it.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param keyId - The API key ID to revoke.
+   * @returns Revocation confirmation.
+   */
+  async revoke(merchantId, keyId) {
+    return this.request(
+      "DELETE",
+      `/api_keys/${encodeURIComponent(merchantId)}/${encodeURIComponent(keyId)}`
+    );
+  }
+  /**
+   * List all API keys for a merchant.
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns Array of API key metadata objects.
+   */
+  async list(merchantId) {
+    return this.request("GET", `/api_keys/${encodeURIComponent(merchantId)}/list`);
+  }
+};
+
+// src/resources/authentication.ts
+var Authentication = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async create(params) {
+    return this.request("POST", "/authentication", { body: params });
+  }
+  async checkEligibility(authId) {
+    return this.request("POST", `/authentication/${encodeURIComponent(authId)}/eligibility`);
+  }
+  async authenticate(authId, params) {
+    return this.request("POST", `/authentication/${encodeURIComponent(authId)}/authenticate`, {
+      body: params
+    });
+  }
+  async sync(authId, params) {
+    return this.request("POST", `/authentication/${encodeURIComponent(authId)}/sync`, {
+      body: params
+    });
+  }
+  /** Redirect after authentication. `POST /authentication/{authId}/redirect` */
+  async redirect(authId, params) {
+    return this.request("POST", `/authentication/${encodeURIComponent(authId)}/redirect`, {
+      body: params
+    });
+  }
+  /** Enable authn methods token. `POST /authentication/{authId}/enabled_authn_methods_token` */
+  async enabledAuthnMethodsToken(authId, params) {
+    return this.request(
+      "POST",
+      `/authentication/${encodeURIComponent(authId)}/enabled_authn_methods_token`,
+      {
+        body: params
+      }
+    );
+  }
+  /** Submit eligibility check. `POST /authentication/{authId}/eligibility-check` */
+  async eligibilityCheck(authId, params) {
+    return this.request("POST", `/authentication/${encodeURIComponent(authId)}/eligibility-check`, {
+      body: params
+    });
+  }
+};
+
+// src/resources/billing.ts
+var BillingAllocations = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Transfer funds from the host merchant treasury into a shop's allocation.
+   *
+   * @param merchantId - The host merchant account ID.
+   * @param params - Transfer details (amount, target profile/shop ID).
+   * @returns The allocation transfer result.
+   */
+  async transferIn(merchantId, params) {
+    return this.request(
+      "POST",
+      `/billing/${encodeURIComponent(merchantId)}/allocations/transfer-in`,
+      { body: params }
+    );
+  }
+  /**
+   * Transfer funds from a shop's allocation back to the host merchant treasury.
+   *
+   * @param merchantId - The host merchant account ID.
+   * @param params - Transfer details (amount, source profile/shop ID).
+   * @returns The allocation transfer result.
+   */
+  async transferOut(merchantId, params) {
+    return this.request(
+      "POST",
+      `/billing/${encodeURIComponent(merchantId)}/allocations/transfer-out`,
+      {
+        body: params
+      }
+    );
+  }
+  /**
+   * List all shop balance allocations for a merchant.
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns List of shop allocations.
+   */
+  async list(merchantId) {
+    return this.request("GET", `/billing/${encodeURIComponent(merchantId)}/allocations`);
+  }
+  /**
+   * Get the balance allocation for a specific shop.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param profileId - The shop (business profile) ID.
+   * @returns The shop's balance allocation.
+   */
+  async get(merchantId, profileId) {
+    return this.request(
+      "GET",
+      `/billing/${encodeURIComponent(merchantId)}/allocations/${encodeURIComponent(profileId)}`
+    );
+  }
+};
+var Billing = class {
+  constructor(request) {
+    this.request = request;
+    this.allocations = new BillingAllocations(request);
+  }
+  /**
+   * Retrieve a merchant's billing profile (balance, status, auto-recharge config).
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns The billing profile.
+   *
+   * @example
+   * ```typescript
+   * const profile = await delopay.billing.getProfile('merch_123');
+   * console.log(profile.balance, profile.status);
+   * ```
+   */
+  async getProfile(merchantId) {
+    return this.request("GET", `/billing/${encodeURIComponent(merchantId)}`);
+  }
+  /**
+   * Start a Stripe SetupIntent flow to collect a payment card for auto-recharge.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - Optional setup parameters.
+   * @returns The Stripe client secret needed to render the card element.
+   */
+  async setup(merchantId, params) {
+    return this.request("POST", `/billing/${encodeURIComponent(merchantId)}/setup`, {
+      body: params
+    });
+  }
+  /**
+   * Confirm card setup after the Stripe SetupIntent completes on the frontend.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - The Stripe SetupIntent ID to confirm.
+   * @returns The updated billing profile.
+   */
+  async completeSetup(merchantId, params) {
+    return this.request("POST", `/billing/${encodeURIComponent(merchantId)}/setup/complete`, {
+      body: params
+    });
+  }
+  /**
+   * Manually top up a merchant's prepaid balance by charging their saved card.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - Top-up amount and currency.
+   * @returns The top-up result.
+   */
+  async topup(merchantId, params) {
+    return this.request("POST", `/billing/${encodeURIComponent(merchantId)}/topup`, {
+      body: params
+    });
+  }
+  /**
+   * List the balance ledger (credits and debits) for a merchant.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - Optional pagination parameters.
+   * @returns The ledger entries.
+   */
+  async listLedger(merchantId, params) {
+    return this.request("GET", `/billing/${encodeURIComponent(merchantId)}/ledger`, {
+      query: params
+    });
+  }
+  /**
+   * Update auto-recharge configuration (threshold, top-up amount, enabled flag).
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - Auto-recharge settings to update.
+   * @returns The updated billing profile.
+   */
+  async updateAutoRecharge(merchantId, params) {
+    return this.request("PATCH", `/billing/${encodeURIComponent(merchantId)}/auto-recharge`, {
+      body: params
+    });
+  }
+  /**
+   * Admin: manually credit a merchant's balance (e.g. promotional credit).
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - Credit amount and reason.
+   * @returns The adjustment result.
+   */
+  async adminCredit(merchantId, params) {
+    return this.request("POST", `/billing/${encodeURIComponent(merchantId)}/admin/credit`, {
+      body: params
+    });
+  }
+  /**
+   * Admin: manually debit a merchant's balance.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - Debit amount and reason.
+   * @returns The adjustment result.
+   */
+  async adminDebit(merchantId, params) {
+    return this.request("POST", `/billing/${encodeURIComponent(merchantId)}/admin/debit`, {
+      body: params
+    });
+  }
+};
+
+// src/resources/blocklist.ts
+var Blocklist = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async add(params) {
+    return this.request("POST", "/blocklist", { body: params });
+  }
+  async remove(params) {
+    return this.request("DELETE", "/blocklist", { body: params });
+  }
+  async list(params) {
+    return this.request("GET", "/blocklist", {
+      query: params
+    });
+  }
+  async toggle(params) {
+    return this.request("POST", "/blocklist/toggle", { body: params });
+  }
+};
+
+// src/resources/cardIssuers.ts
+var CardIssuers = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async create(params) {
+    return this.request("POST", "/card_issuers", { body: params });
+  }
+  async update(issuerId, params) {
+    return this.request("PUT", `/card_issuers/${encodeURIComponent(issuerId)}`, { body: params });
+  }
+  async list() {
+    return this.request("GET", "/card_issuers");
+  }
+};
+
+// src/resources/connectors.ts
+var Connectors = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async create(accountId, params) {
+    return this.request("POST", `/account/${encodeURIComponent(accountId)}/connectors`, {
+      body: params
+    });
+  }
+  async retrieve(accountId, connectorId) {
+    return this.request(
+      "GET",
+      `/account/${encodeURIComponent(accountId)}/connectors/${encodeURIComponent(connectorId)}`
+    );
+  }
+  async list(accountId) {
+    return this.request("GET", `/account/${encodeURIComponent(accountId)}/connectors`);
+  }
+  async update(accountId, connectorId, params) {
+    return this.request(
+      "POST",
+      `/account/${encodeURIComponent(accountId)}/connectors/${encodeURIComponent(connectorId)}`,
+      {
+        body: params
+      }
+    );
+  }
+  async delete(accountId, connectorId) {
+    return this.request(
+      "DELETE",
+      `/account/${encodeURIComponent(accountId)}/connectors/${encodeURIComponent(connectorId)}`
+    );
+  }
+  // --- Advanced operations (Task 4.8) ---
+  /** Verify connector credentials. `POST /account/connectors/verify` */
+  async verify(params) {
+    return this.request("POST", "/account/connectors/verify", { body: params });
+  }
+  /** Register a webhook for a connector. `POST /account/{merchantId}/connectors/webhooks/{connectorId}` */
+  async registerWebhook(merchantId, connectorId) {
+    return this.request(
+      "POST",
+      `/account/${encodeURIComponent(merchantId)}/connectors/webhooks/${encodeURIComponent(connectorId)}`
+    );
+  }
+  /** Get a webhook for a connector. `GET /account/{merchantId}/connectors/webhooks/{connectorId}` */
+  async getWebhook(merchantId, connectorId) {
+    return this.request(
+      "GET",
+      `/account/${encodeURIComponent(merchantId)}/connectors/webhooks/${encodeURIComponent(connectorId)}`
+    );
+  }
+  /** List available payment methods. `GET /account/payment_methods` */
+  async listPaymentMethods() {
+    return this.request("GET", "/account/payment_methods");
+  }
+};
+
+// src/resources/customers.ts
+var Customers = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new customer.
+   *
+   * @param params - Customer creation parameters (name, email, phone, address, etc.).
+   * @returns The created customer.
+   *
+   * @example
+   * ```typescript
+   * const customer = await delopay.customers.create({
+   *   email: 'alice@example.com',
+   *   name: 'Alice Smith',
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.request("POST", "/customers", { body: params });
+  }
+  /**
+   * Retrieve a customer by their ID.
+   *
+   * @param customerId - The unique customer ID.
+   * @returns The customer.
+   *
+   * @example
+   * ```typescript
+   * const customer = await delopay.customers.retrieve('cus_abc123');
+   * ```
+   */
+  async retrieve(customerId) {
+    return this.request("GET", `/customers/${encodeURIComponent(customerId)}`);
+  }
+  /**
+   * Update an existing customer's details.
+   *
+   * @param customerId - The customer ID to update.
+   * @param params - Fields to update (name, email, address, metadata, etc.).
+   * @returns The updated customer.
+   */
+  async update(customerId, params) {
+    return this.request("POST", `/customers/${encodeURIComponent(customerId)}`, { body: params });
+  }
+  /**
+   * Delete a customer and all their saved payment methods.
+   *
+   * @param customerId - The customer ID to delete.
+   * @returns The deleted customer object.
+   */
+  async delete(customerId) {
+    return this.request("DELETE", `/customers/${encodeURIComponent(customerId)}`);
+  }
+  /**
+   * List customers, optionally filtered by email.
+   *
+   * @param params - Optional filter and pagination parameters.
+   * @returns Array of customer objects.
+   */
+  async list(params) {
+    return this.request("GET", "/customers/list", {
+      query: params
+    });
+  }
+  // --- OLAP extensions (Task 4.6) ---
+  /** List customers with count. `GET /customers/list_with_count` */
+  async listWithCount(params) {
+    return this.request("GET", "/customers/list_with_count", {
+      query: params
+    });
+  }
+  /** List mandates for a customer. `GET /customers/{customerId}/mandates` */
+  async listMandates(customerId) {
+    return this.request("GET", `/customers/${encodeURIComponent(customerId)}/mandates`);
+  }
+};
+
+// src/resources/disputes.ts
+var Disputes = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Retrieve a dispute by its ID.
+   *
+   * @param disputeId - The unique dispute ID.
+   * @returns The dispute.
+   */
+  async retrieve(disputeId) {
+    return this.request("GET", `/disputes/${encodeURIComponent(disputeId)}`);
+  }
+  /**
+   * List disputes, optionally filtered by status, stage, or date range.
+   *
+   * @param params - Optional filter and pagination parameters.
+   * @returns Array of disputes.
+   */
+  async list(params) {
+    return this.request("GET", "/disputes/list", {
+      query: params
+    });
+  }
+  /**
+   * Accept a dispute, conceding the chargeback to the customer.
+   *
+   * @param disputeId - The dispute ID to accept.
+   * @returns The updated dispute.
+   */
+  async accept(disputeId) {
+    return this.request("POST", `/disputes/accept/${encodeURIComponent(disputeId)}`);
+  }
+  /**
+   * Submit evidence to challenge a dispute.
+   *
+   * @param params - Evidence details and the dispute ID to contest.
+   * @returns The updated dispute.
+   */
+  async submitEvidence(params) {
+    return this.request("POST", "/disputes/evidence", { body: params });
+  }
+  /**
+   * Attach evidence (e.g. file upload metadata) to a dispute.
+   *
+   * Uses `PUT /disputes/evidence`.
+   */
+  async attachEvidence(params) {
+    return this.request("PUT", "/disputes/evidence", { body: params });
+  }
+  /**
+   * Retrieve previously submitted evidence for a dispute.
+   *
+   * @param disputeId - The dispute ID.
+   * @returns The submitted evidence.
+   */
+  async retrieveEvidence(disputeId) {
+    return this.request("GET", `/disputes/evidence/${encodeURIComponent(disputeId)}`);
+  }
+  /**
+   * Delete submitted evidence for a dispute.
+   *
+   * @param params - Evidence request body identifying what to delete.
+   * @returns The updated dispute.
+   */
+  async deleteEvidence(params) {
+    return this.request("DELETE", "/disputes/evidence", { body: params });
+  }
+  // --- OLAP extensions (Task 4.4) ---
+  /** List disputes (profile-scoped). `GET /disputes/profile/list` */
+  async listByProfile(params) {
+    return this.request("GET", "/disputes/profile/list", {
+      query: params
+    });
+  }
+  /** Get dispute filter options. `GET /disputes/filter` */
+  async getFilters(params) {
+    return this.request("GET", "/disputes/filter", { query: params });
+  }
+  /** Get dispute filters (profile-scoped). `GET /disputes/profile/filter` */
+  async getFiltersByProfile(params) {
+    return this.request("GET", "/disputes/profile/filter", { query: params });
+  }
+  /** Get dispute aggregates. `GET /disputes/aggregate` */
+  async aggregate(params) {
+    return this.request("GET", "/disputes/aggregate", { query: params });
+  }
+  /** Get dispute aggregates (profile-scoped). `GET /disputes/profile/aggregate` */
+  async aggregateByProfile(params) {
+    return this.request("GET", "/disputes/profile/aggregate", { query: params });
+  }
+  /**
+   * Fetch the latest dispute state from the connector (gateway).
+   * `GET /disputes/{connectorId}/fetch`
+   *
+   * Note: the path parameter is the **connector dispute id** on the gateway, not the
+   * Delopay dispute id. Method is GET (not POST) and this method signature was
+   * previously wrong — callers depending on the old `POST /disputes/{id}/fetch_from_connector`
+   * path were silently hitting 404s.
+   */
+  async fetchFromConnector(connectorId) {
+    return this.request("GET", `/disputes/${encodeURIComponent(connectorId)}/fetch`);
+  }
+};
+
+// src/resources/ephemeralKeys.ts
+var EphemeralKeys = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create an ephemeral key scoped to a specific customer.
+   *
+   * @param params - Customer ID and optional expiry.
+   * @returns The ephemeral key with its plaintext secret and expiry timestamp.
+   *
+   * @example
+   * ```typescript
+   * const ephKey = await delopay.ephemeralKeys.create({ customer_id: 'cus_123' });
+   * // Pass ephKey.secret to your mobile app.
+   * ```
+   */
+  async create(params) {
+    return this.request("POST", "/ephemeral_keys", { body: params });
+  }
+  /**
+   * Invalidate an ephemeral key before it expires.
+   *
+   * @param keyId - The ephemeral key ID to delete.
+   * @returns The deleted key object.
+   */
+  async delete(keyId) {
+    return this.request("DELETE", `/ephemeral_keys/${encodeURIComponent(keyId)}`);
+  }
+};
+
+// src/resources/events.ts
+var Events = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async list(merchantId, params) {
+    return this.request("POST", `/events/${encodeURIComponent(merchantId)}`, { body: params });
+  }
+  async listDeliveryAttempts(merchantId, eventId) {
+    return this.request(
+      "GET",
+      `/events/${encodeURIComponent(merchantId)}/${encodeURIComponent(eventId)}/attempts`
+    );
+  }
+  async retryDelivery(merchantId, eventId) {
+    return this.request(
+      "POST",
+      `/events/${encodeURIComponent(merchantId)}/${encodeURIComponent(eventId)}/retry`
+    );
+  }
+  // --- Profile-scoped listing (Task 4.12) ---
+  /** List events (profile-scoped). `POST /events/profile/list` */
+  async listByProfile(params) {
+    return this.request("POST", "/events/profile/list", { body: params });
+  }
+};
+
+// src/resources/fees.ts
+var PlatformFees = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new platform fee schedule for a merchant (admin only).
+   *
+   * @param params - Fee schedule parameters (percentage, flat fee, min/max).
+   * @param merchantId - The merchant account to attach the schedule to.
+   * @returns The created fee schedule.
+   */
+  async create(params, merchantId) {
+    return this.request("POST", "/admin/fees", {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * List all platform fee schedules for a merchant (admin only).
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns Array of fee schedules.
+   */
+  async list(merchantId) {
+    return this.request("GET", "/admin/fees/list", {
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Retrieve a single fee schedule by ID (admin only).
+   *
+   * @param feeId - The fee schedule ID.
+   * @returns The fee schedule.
+   */
+  async retrieve(feeId) {
+    return this.request("GET", `/admin/fees/${encodeURIComponent(feeId)}`);
+  }
+  /**
+   * Update a fee schedule (admin only).
+   *
+   * @param feeId - The fee schedule ID to update.
+   * @param params - Fields to update.
+   * @returns The updated fee schedule.
+   */
+  async update(feeId, params) {
+    return this.request("PUT", `/admin/fees/${encodeURIComponent(feeId)}`, { body: params });
+  }
+  /**
+   * Delete a fee schedule (admin only).
+   *
+   * @param feeId - The fee schedule ID to delete.
+   * @returns The deleted fee schedule.
+   */
+  async delete(feeId) {
+    return this.request("DELETE", `/admin/fees/${encodeURIComponent(feeId)}`);
+  }
+};
+var MerchantFees = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a merchant-scoped fee schedule override for a specific shop.
+   *
+   * @param params - Fee schedule parameters.
+   * @param merchantId - The merchant account ID.
+   * @returns The created fee schedule.
+   */
+  async create(params, merchantId) {
+    return this.request("POST", "/merchant_fees", {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * List merchant-scoped fee schedules.
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns Array of fee schedules.
+   */
+  async list(merchantId) {
+    return this.request("GET", "/merchant_fees/list", {
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Update a merchant-scoped fee schedule.
+   *
+   * @param feeId - The fee schedule ID to update.
+   * @param params - Fields to update.
+   * @returns The updated fee schedule.
+   */
+  async update(feeId, params) {
+    return this.request("PUT", `/merchant_fees/${encodeURIComponent(feeId)}`, { body: params });
+  }
+  /**
+   * Delete a merchant-scoped fee schedule.
+   *
+   * @param feeId - The fee schedule ID to delete.
+   * @returns The deleted fee schedule.
+   */
+  async delete(feeId) {
+    return this.request("DELETE", `/merchant_fees/${encodeURIComponent(feeId)}`);
+  }
+};
+var Fees = class {
+  constructor(request) {
+    this.platform = new PlatformFees(request);
+    this.merchant = new MerchantFees(request);
+  }
+};
+
+// src/resources/gsm.ts
+var Gsm = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async create(params) {
+    return this.request("POST", "/gsm", { body: params });
+  }
+  async retrieve(params) {
+    return this.request("POST", "/gsm/get", { body: params });
+  }
+  async update(params) {
+    return this.request("POST", "/gsm/update", { body: params });
+  }
+  async delete(params) {
+    return this.request("POST", "/gsm/delete", { body: params });
+  }
+};
+
+// src/resources/mandates.ts
+var Mandates = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Retrieve a mandate by its ID.
+   *
+   * @param mandateId - The unique mandate ID.
+   * @returns The mandate.
+   */
+  async retrieve(mandateId) {
+    return this.request("GET", `/mandates/${encodeURIComponent(mandateId)}`);
+  }
+  /**
+   * Revoke an active mandate, preventing future charges.
+   *
+   * @param mandateId - The mandate ID to revoke.
+   * @returns Revocation confirmation.
+   */
+  async revoke(mandateId) {
+    return this.request("POST", `/mandates/revoke/${encodeURIComponent(mandateId)}`);
+  }
+  /**
+   * List mandates, optionally filtered by customer or status.
+   *
+   * @param params - Optional filter and pagination parameters.
+   * @returns Array of mandates.
+   */
+  async list(params) {
+    return this.request("GET", "/mandates/list", {
+      query: params
+    });
+  }
+};
+
+// src/resources/merchantAccounts.ts
+var MerchantAccounts = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async create(params) {
+    return this.request("POST", "/accounts", { body: params });
+  }
+  async retrieve(accountId) {
+    return this.request("GET", `/accounts/${encodeURIComponent(accountId)}`);
+  }
+  async update(accountId, params) {
+    return this.request("POST", `/accounts/${encodeURIComponent(accountId)}`, { body: params });
+  }
+  async delete(accountId) {
+    return this.request("DELETE", `/accounts/${encodeURIComponent(accountId)}`);
+  }
+  // --- Advanced operations (Task 4.9) ---
+  /** List all merchant accounts. `GET /accounts/list` */
+  async list() {
+    return this.request("GET", "/accounts/list");
+  }
+  /** Toggle key-value store for a merchant. `POST /accounts/{accountId}/kv` */
+  async toggleKv(accountId) {
+    return this.request("POST", `/accounts/${encodeURIComponent(accountId)}/kv`);
+  }
+  /** Get KV status for a merchant. `GET /accounts/{accountId}/kv` */
+  async getKvStatus(accountId) {
+    return this.request("GET", `/accounts/${encodeURIComponent(accountId)}/kv`);
+  }
+  /** Transfer keys between merchants. `POST /accounts/transfer` */
+  async transferKeys(params) {
+    return this.request("POST", "/accounts/transfer", { body: params });
+  }
+};
+
+// src/resources/paymentLinks.ts
+var PaymentLinks = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Retrieve a payment link by its ID.
+   *
+   * @param linkId - The unique payment link ID.
+   * @returns The payment link details.
+   */
+  async retrieve(linkId) {
+    return this.request("GET", `/payment_link/${encodeURIComponent(linkId)}`);
+  }
+  /**
+   * List payment links, optionally filtered by status or date range.
+   *
+   * @param params - Optional filter and pagination parameters.
+   * @returns Paginated list of payment links.
+   */
+  async list(params) {
+    return this.request("POST", "/payment_link/list", { body: params });
+  }
+  /** Initiate (render) a payment link page. `GET /payment_link/{merchantId}/{paymentId}` */
+  async initiate(merchantId, paymentId) {
+    return this.request(
+      "GET",
+      `/payment_link/${encodeURIComponent(merchantId)}/${encodeURIComponent(paymentId)}`
+    );
+  }
+  /** Get payment link status. `GET /payment_linkstatus/{merchantId}/{paymentId}` */
+  async status(merchantId, paymentId) {
+    return this.request(
+      "GET",
+      `/payment_linkstatus/${encodeURIComponent(merchantId)}/${encodeURIComponent(paymentId)}`
+    );
+  }
+};
+
+// src/resources/paymentMethods.ts
+var PaymentMethods = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Save a new payment method (card, bank account, wallet, etc.).
+   *
+   * @param params - Payment method data including type and card/bank details.
+   * @returns The saved payment method.
+   *
+   * @example
+   * ```typescript
+   * const pm = await delopay.paymentMethods.create({
+   *   payment_method: 'card',
+   *   customer_id: 'cus_123',
+   *   client_secret: 'cs_...',
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.request("POST", "/payment_methods", { body: params });
+  }
+  /**
+   * Retrieve a saved payment method by its ID.
+   *
+   * @param methodId - The payment method ID.
+   * @returns The payment method.
+   */
+  async retrieve(methodId) {
+    return this.request("GET", `/payment_methods/${encodeURIComponent(methodId)}`);
+  }
+  /**
+   * Update an existing payment method (e.g. update card expiry).
+   *
+   * @param methodId - The payment method ID to update.
+   * @param params - Fields to update (card expiry, holder name, etc.).
+   * @returns The updated payment method.
+   */
+  async update(methodId, params) {
+    return this.request("POST", `/payment_methods/${encodeURIComponent(methodId)}/update`, {
+      body: params
+    });
+  }
+  /**
+   * Delete a saved payment method.
+   *
+   * @param methodId - The payment method ID to delete.
+   * @returns Deletion confirmation.
+   */
+  async delete(methodId) {
+    return this.request("DELETE", `/payment_methods/${encodeURIComponent(methodId)}`);
+  }
+  /**
+   * List payment methods using a client secret.
+   *
+   * @param params - Filter by `client_secret`.
+   * @returns Array of payment methods.
+   */
+  async list(params) {
+    return this.request("GET", "/payment_methods", {
+      query: params
+    });
+  }
+  /**
+   * List all saved payment methods for a customer, optionally filtered.
+   *
+   * @param customerId - The customer ID.
+   * @param params - Optional filters: `client_secret`, `accepted_countries`, `accepted_currencies`,
+   *   `amount`, `recurring_enabled`, `installment_payment_enabled`, `limit`, `card_networks`.
+   * @returns Customer's saved payment methods.
+   *
+   * @example
+   * ```typescript
+   * const { customer_payment_methods } = await delopay.paymentMethods.listForCustomer(
+   *   'cus_123',
+   *   { accepted_currencies: ['EUR'], amount: 5000 },
+   * );
+   * ```
+   */
+  async listForCustomer(customerId, params) {
+    return this.request("GET", `/customers/${encodeURIComponent(customerId)}/payment_methods`, {
+      query: params
+    });
+  }
+  /**
+   * Set a payment method as the default for a customer.
+   *
+   * @param customerId - The customer ID.
+   * @param methodId - The payment method ID to set as default.
+   * @returns The updated payment method.
+   */
+  async setDefault(customerId, methodId) {
+    return this.request(
+      "POST",
+      `/customers/${encodeURIComponent(customerId)}/payment_methods/${encodeURIComponent(methodId)}/default`
+    );
+  }
+  // --- Advanced operations (Task 3.3) ---
+  /** Migrate a payment method. `POST /payment_methods/migrate` */
+  async migrate(params) {
+    return this.request("POST", "/payment_methods/migrate", { body: params });
+  }
+  /** Batch migrate payment methods. `POST /payment_methods/migrate-batch` */
+  async migrateBatch(params) {
+    return this.request("POST", "/payment_methods/migrate-batch", { body: params });
+  }
+  /** Batch update payment methods. `POST /payment_methods/update-batch` */
+  async updateBatch(params) {
+    return this.request("POST", "/payment_methods/update-batch", { body: params });
+  }
+  /** Batch retrieve payment methods. `GET /payment_methods/batch` */
+  async batchRetrieve(params) {
+    return this.request("GET", "/payment_methods/batch", { query: params });
+  }
+  /** Tokenize a card. `POST /payment_methods/tokenize-card` */
+  async tokenizeCard(params) {
+    return this.request("POST", "/payment_methods/tokenize-card", { body: params });
+  }
+  /** Batch tokenize cards. `POST /payment_methods/tokenize-card-batch` */
+  async tokenizeCardBatch(params) {
+    return this.request("POST", "/payment_methods/tokenize-card-batch", { body: params });
+  }
+  /** Initiate payment method collect link flow. `POST /payment_methods/collect` */
+  async collect(params) {
+    return this.request("POST", "/payment_methods/collect", { body: params });
+  }
+  /** Save a payment method. `POST /payment_methods/{methodId}/save` */
+  async save(methodId, params) {
+    return this.request("POST", `/payment_methods/${encodeURIComponent(methodId)}/save`, {
+      body: params
+    });
+  }
+  /** Create payment method auth link token. `POST /payment_methods/auth/link` */
+  async createAuthLink(params) {
+    return this.request("POST", "/payment_methods/auth/link", { body: params });
+  }
+  /** Exchange payment method auth token. `POST /payment_methods/auth/exchange` */
+  async exchangeAuthToken(params) {
+    return this.request("POST", "/payment_methods/auth/exchange", { body: params });
+  }
+  /** Tokenize card using existing PM. `POST /payment_methods/{methodId}/tokenize-card` */
+  async tokenizeCardForMethod(methodId, params) {
+    return this.request("POST", `/payment_methods/${encodeURIComponent(methodId)}/tokenize-card`, {
+      body: params
+    });
+  }
+};
+
+// src/resources/payments.ts
+var Payments = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new payment intent.
+   *
+   * @param params - Payment creation parameters including amount and currency.
+   * @returns The created payment intent.
+   *
+   * @example
+   * ```typescript
+   * const payment = await delopay.payments.create({
+   *   amount: 5000,
+   *   currency: 'EUR',
+   *   customer_id: 'cus_123',
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.request("POST", "/payments", { body: params });
+  }
+  /**
+   * Retrieve a payment by its ID.
+   *
+   * @param paymentId - The unique payment intent ID.
+   * @returns The payment intent.
+   *
+   * @example
+   * ```typescript
+   * const payment = await delopay.payments.retrieve('pay_abc123');
+   * ```
+   */
+  async retrieve(paymentId) {
+    return this.request("GET", `/payments/${encodeURIComponent(paymentId)}`);
+  }
+  /**
+   * Update an existing payment intent before it is confirmed.
+   *
+   * @param paymentId - The payment intent ID to update.
+   * @param params - Fields to update (amount, currency, metadata, etc.).
+   * @returns The updated payment intent.
+   */
+  async update(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}`, { body: params });
+  }
+  /**
+   * Confirm a payment intent, triggering authorisation with the selected gateway.
+   *
+   * @param paymentId - The payment intent ID to confirm.
+   * @param params - Confirmation parameters (payment method data, return URL, etc.).
+   * @returns The updated payment intent.
+   */
+  async confirm(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/confirm`, {
+      body: params
+    });
+  }
+  /**
+   * Capture a previously authorised payment.
+   *
+   * @param paymentId - The payment intent ID to capture.
+   * @param params - Optional capture parameters (partial capture amount, etc.).
+   * @returns The updated payment intent.
+   */
+  async capture(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/capture`, {
+      body: params
+    });
+  }
+  /**
+   * Cancel a payment intent that has not yet been captured.
+   *
+   * @param paymentId - The payment intent ID to cancel.
+   * @param params - Optional cancellation reason.
+   * @returns The updated payment intent.
+   */
+  async cancel(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/cancel`, {
+      body: params
+    });
+  }
+  /**
+   * List payment intents, optionally filtered by customer or date range.
+   *
+   * @param params - Optional filter and pagination parameters.
+   * @returns Paginated list of payment intents.
+   *
+   * @example
+   * ```typescript
+   * const { data } = await delopay.payments.list({ customer_id: 'cus_123', limit: 25 });
+   * ```
+   */
+  async list(params) {
+    return this.request("GET", "/payments/list", {
+      query: params
+    });
+  }
+  // --- Advanced operations (Task 3.2) ---
+  /** Generate session tokens. `POST /payments/session_tokens` */
+  async sessionTokens(params) {
+    return this.request("POST", "/payments/session_tokens", { body: params });
+  }
+  /** Retrieve payment with gateway credentials. `POST /payments/sync` */
+  async sync(params) {
+    return this.request("POST", "/payments/sync", { body: params });
+  }
+  /** Cancel after partial capture. `POST /payments/{paymentId}/cancel_post_capture` */
+  async cancelPostCapture(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/cancel_post_capture`, {
+      body: params
+    });
+  }
+  /** Incrementally authorize more funds. `POST /payments/{paymentId}/incremental_authorization` */
+  async incrementalAuthorization(paymentId, params) {
+    return this.request(
+      "POST",
+      `/payments/${encodeURIComponent(paymentId)}/incremental_authorization`,
+      {
+        body: params
+      }
+    );
+  }
+  /** Extend authorization window. `POST /payments/{paymentId}/extend_authorization` */
+  async extendAuthorization(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/extend_authorization`, {
+      body: params
+    });
+  }
+  /** Complete authorization. `POST /payments/{paymentId}/complete_authorize` */
+  async completeAuthorize(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/complete_authorize`, {
+      body: params
+    });
+  }
+  /** Dynamic tax calculation. `POST /payments/{paymentId}/calculate_tax` */
+  async calculateTax(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/calculate_tax`, {
+      body: params
+    });
+  }
+  /** Update payment metadata. `POST /payments/{paymentId}/update_metadata` */
+  async updateMetadata(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/update_metadata`, {
+      body: params
+    });
+  }
+  /** Retrieve extended card info. `GET /payments/{paymentId}/extended_card_info` */
+  async extendedCardInfo(paymentId) {
+    return this.request("GET", `/payments/${encodeURIComponent(paymentId)}/extended_card_info`);
+  }
+  // --- OLAP extensions (Task 4.2) ---
+  /** List payments (profile-scoped). `GET /payments/profile/list` */
+  async listByProfile(params) {
+    return this.request("GET", "/payments/profile/list", {
+      query: params
+    });
+  }
+  /** List payments across all shops. `GET /payments/list-all-shops` */
+  async listAllShops(params) {
+    return this.request("GET", "/payments/list-all-shops", {
+      query: params
+    });
+  }
+  /** List payments by filter (POST body). `POST /payments/list` */
+  async listByFilter(params) {
+    return this.request("POST", "/payments/list", { body: params });
+  }
+  /** Get payment filter options. `POST /payments/filter` */
+  async getFilters(params) {
+    return this.request("POST", "/payments/filter", { body: params });
+  }
+  /** Get payment filters (v2). `GET /payments/v2/filter` */
+  async getFiltersV2(params) {
+    return this.request("GET", "/payments/v2/filter", { query: params });
+  }
+  /** Get payment aggregates. `GET /payments/aggregate` */
+  async aggregate(params) {
+    return this.request("GET", "/payments/aggregate", { query: params });
+  }
+  /** Get payment aggregates (profile-scoped). `GET /payments/profile/aggregate` */
+  async aggregateByProfile(params) {
+    return this.request("GET", "/payments/profile/aggregate", { query: params });
+  }
+  /** Manually update payment status. `PUT /payments/{paymentId}/manual-update` */
+  async manualUpdate(paymentId, params) {
+    return this.request("PUT", `/payments/${encodeURIComponent(paymentId)}/manual-update`, {
+      body: params
+    });
+  }
+  /** Approve a payment waiting for review. `POST /payments/{paymentId}/approve` */
+  async approve(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/approve`, {
+      body: params
+    });
+  }
+  /** Reject a payment waiting for review. `POST /payments/{paymentId}/reject` */
+  async reject(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/reject`, {
+      body: params
+    });
+  }
+  /** Initiate external 3DS authentication. `POST /payments/{paymentId}/3ds/authentication` */
+  async threeDsAuthentication(paymentId, params) {
+    return this.request("POST", `/payments/${encodeURIComponent(paymentId)}/3ds/authentication`, {
+      body: params
+    });
+  }
+};
+
+// src/resources/payouts.ts
+var Payouts = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new payout.
+   *
+   * @param params - Payout parameters including amount, currency, and destination.
+   * @returns The created payout.
+   *
+   * @example
+   * ```typescript
+   * const payout = await delopay.payouts.create({
+   *   amount: 10000,
+   *   currency: 'EUR',
+   *   customer_id: 'cus_123',
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.request("POST", "/payouts/create", { body: params });
+  }
+  /**
+   * Retrieve a payout by its ID.
+   *
+   * @param payoutId - The unique payout ID.
+   * @returns The payout.
+   */
+  async retrieve(payoutId) {
+    return this.request("GET", `/payouts/${encodeURIComponent(payoutId)}`);
+  }
+  /**
+   * Update a payout before it is confirmed.
+   *
+   * @param payoutId - The payout ID to update.
+   * @param params - Fields to update.
+   * @returns The updated payout.
+   */
+  async update(payoutId, params) {
+    return this.request("PUT", `/payouts/${encodeURIComponent(payoutId)}`, { body: params });
+  }
+  /**
+   * Confirm a payout, triggering the actual transfer.
+   *
+   * @param payoutId - The payout ID to confirm.
+   * @param params - Optional confirmation parameters.
+   * @returns The updated payout.
+   */
+  async confirm(payoutId, params) {
+    return this.request("POST", `/payouts/${encodeURIComponent(payoutId)}/confirm`, {
+      body: params
+    });
+  }
+  /**
+   * Cancel a payout before it is fulfilled.
+   *
+   * @param payoutId - The payout ID to cancel.
+   * @returns The cancelled payout.
+   */
+  async cancel(payoutId) {
+    return this.request("POST", `/payouts/${encodeURIComponent(payoutId)}/cancel`);
+  }
+  /**
+   * Mark a payout as fulfilled (manual confirmation of successful transfer).
+   *
+   * @param payoutId - The payout ID to fulfil.
+   * @returns The fulfilled payout.
+   */
+  async fulfill(payoutId) {
+    return this.request("POST", `/payouts/${encodeURIComponent(payoutId)}/fulfill`);
+  }
+  /**
+   * List payouts, optionally filtered by status or date range.
+   *
+   * @param params - Optional filter and pagination parameters.
+   * @returns Paginated list of payouts.
+   */
+  async list(params) {
+    return this.request("GET", "/payouts/list", {
+      query: params
+    });
+  }
+  // --- OLAP extensions (Task 4.5) ---
+  /** List payouts (profile-scoped). `GET /payouts/profile/list` */
+  async listByProfile(params) {
+    return this.request("GET", "/payouts/profile/list", {
+      query: params
+    });
+  }
+  /** List payouts by filter (POST body). `POST /payouts/list` */
+  async listByFilter(params) {
+    return this.request("POST", "/payouts/list", { body: params });
+  }
+  /** Get payout filter options. `POST /payouts/filter` */
+  async getFilters(params) {
+    return this.request("POST", "/payouts/filter", { body: params });
+  }
+  /** Get payout filters (profile-scoped). `POST /payouts/profile/filter` */
+  async getFiltersByProfile(params) {
+    return this.request("POST", "/payouts/profile/filter", { body: params });
+  }
+  /** Get payout aggregates. `GET /payouts/aggregate` */
+  async aggregate(params) {
+    return this.request("GET", "/payouts/aggregate", { query: params });
+  }
+  /** Get payout aggregates (profile-scoped). `GET /payouts/profile/aggregate` */
+  async aggregateByProfile(params) {
+    return this.request("GET", "/payouts/profile/aggregate", { query: params });
+  }
+  /** Manually update payout status. `PUT /payouts/{payoutId}/manual-update` */
+  async manualUpdate(payoutId, params) {
+    return this.request("PUT", `/payouts/${encodeURIComponent(payoutId)}/manual-update`, {
+      body: params
+    });
+  }
+};
+
+// src/resources/poll.ts
+var Poll = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async getStatus(pollId) {
+    return this.request("GET", `/poll/status/${encodeURIComponent(pollId)}`);
+  }
+};
+
+// src/resources/profileAcquirers.ts
+var ProfileAcquirers = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async create(params) {
+    return this.request("POST", "/profile_acquirer", { body: params });
+  }
+  async update(profileId, profileAcquirerId, params) {
+    return this.request(
+      "POST",
+      `/profile_acquirer/${encodeURIComponent(profileId)}/${encodeURIComponent(profileAcquirerId)}`,
+      {
+        body: params
+      }
+    );
+  }
+};
+
+// src/resources/profiles.ts
+var Profiles = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async create(accountId, params) {
+    return this.request("POST", `/account/${encodeURIComponent(accountId)}/business_profile`, {
+      body: params
+    });
+  }
+  async retrieve(accountId, profileId) {
+    return this.request(
+      "GET",
+      `/account/${encodeURIComponent(accountId)}/business_profile/${encodeURIComponent(profileId)}`
+    );
+  }
+  async list(accountId) {
+    return this.request("GET", `/account/${encodeURIComponent(accountId)}/business_profile`);
+  }
+  async update(accountId, profileId, params) {
+    return this.request(
+      "POST",
+      `/account/${encodeURIComponent(accountId)}/business_profile/${encodeURIComponent(profileId)}`,
+      {
+        body: params
+      }
+    );
+  }
+  async delete(accountId, profileId) {
+    return this.request(
+      "DELETE",
+      `/account/${encodeURIComponent(accountId)}/business_profile/${encodeURIComponent(profileId)}`
+    );
+  }
+  // --- Advanced operations (Task 4.8) ---
+  /** Toggle extended card info for a profile. `POST /account/{accountId}/business_profile/{profileId}/toggle_extended_card_info` */
+  async toggleExtendedCardInfo(accountId, profileId) {
+    return this.request(
+      "POST",
+      `/account/${encodeURIComponent(accountId)}/business_profile/${encodeURIComponent(profileId)}/toggle_extended_card_info`
+    );
+  }
+  /** Toggle connector agnostic MIT. `POST /account/{accountId}/business_profile/{profileId}/toggle_connector_agnostic_mit` */
+  async toggleConnectorAgnosticMit(accountId, profileId) {
+    return this.request(
+      "POST",
+      `/account/${encodeURIComponent(accountId)}/business_profile/${encodeURIComponent(profileId)}/toggle_connector_agnostic_mit`
+    );
+  }
+};
+
+// src/resources/projects.ts
+var Projects = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new project under a merchant account.
+   *
+   * @param params - Project creation parameters (name, description, etc.).
+   * @param merchantId - The merchant account ID that owns this project.
+   * @returns The created project.
+   *
+   * @example
+   * ```typescript
+   * const project = await delopay.projects.create({ name: 'EU Stores' }, 'merch_123');
+   * ```
+   */
+  async create(params, merchantId) {
+    return this.request("POST", "/projects", {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Retrieve a project by its ID.
+   *
+   * @param projectId - The unique project ID.
+   * @returns The project.
+   */
+  async retrieve(projectId) {
+    return this.request("GET", `/projects/${encodeURIComponent(projectId)}`);
+  }
+  /**
+   * Update a project's details.
+   *
+   * @param projectId - The project ID to update.
+   * @param params - Fields to update.
+   * @returns The updated project.
+   */
+  async update(projectId, params) {
+    return this.request("PUT", `/projects/${encodeURIComponent(projectId)}`, { body: params });
+  }
+  /**
+   * Delete a project.
+   *
+   * @param projectId - The project ID to delete.
+   * @returns The deleted project object.
+   */
+  async delete(projectId) {
+    return this.request("DELETE", `/projects/${encodeURIComponent(projectId)}`);
+  }
+  /**
+   * List all projects for a merchant.
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns Array of projects.
+   */
+  async list(merchantId) {
+    return this.request("GET", "/projects/list", {
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Get aggregate payment statistics across all projects for a merchant.
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns Project statistics.
+   */
+  async stats(merchantId) {
+    return this.request("GET", "/projects/stats", {
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Get a high-level overview (volume, counts, top connectors) for a merchant.
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns Merchant overview data.
+   */
+  async overview(merchantId) {
+    return this.request("GET", "/projects/overview", {
+      query: { merchant_id: merchantId }
+    });
+  }
+};
+
+// src/resources/refunds.ts
+var Refunds = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a refund for a payment.
+   *
+   * @param params - Refund parameters, including the required `payment_id` and optional amount.
+   * @returns The created refund.
+   *
+   * @example
+   * ```typescript
+   * const refund = await delopay.refunds.create({
+   *   payment_id: 'pay_abc123',
+   *   amount: 2500, // partial refund of 25.00 EUR
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.request("POST", "/refunds", { body: params });
+  }
+  /**
+   * Retrieve a refund by its ID.
+   *
+   * @param refundId - The unique refund ID.
+   * @returns The refund.
+   *
+   * @example
+   * ```typescript
+   * const refund = await delopay.refunds.retrieve('ref_abc123');
+   * ```
+   */
+  async retrieve(refundId) {
+    return this.request("GET", `/refunds/${encodeURIComponent(refundId)}`);
+  }
+  /**
+   * Update the reason or metadata on an existing refund.
+   *
+   * @param refundId - The refund ID to update.
+   * @param params - Fields to update (reason, metadata).
+   * @returns The updated refund.
+   */
+  async update(refundId, params) {
+    return this.request("POST", `/refunds/${encodeURIComponent(refundId)}`, { body: params });
+  }
+  /**
+   * List refunds, optionally filtered by payment, status, or date range.
+   *
+   * @param params - Optional filter and pagination parameters.
+   * @returns Paginated list of refunds.
+   */
+  async list(params) {
+    return this.request("POST", "/refunds/list", { body: params });
+  }
+  // --- OLAP extensions (Task 4.3) ---
+  /** List refunds (profile-scoped). `POST /refunds/profile/list` */
+  async listByProfile(params) {
+    return this.request("POST", "/refunds/profile/list", { body: params });
+  }
+  /** Get refund filter options. `POST /refunds/filter` */
+  async getFilters(params) {
+    return this.request("POST", "/refunds/filter", { body: params });
+  }
+  /** Get refund filters (v2). `GET /refunds/v2/filter` */
+  async getFiltersV2(params) {
+    return this.request("GET", "/refunds/v2/filter", { query: params });
+  }
+  /** Get refund aggregates. `GET /refunds/aggregate` */
+  async aggregate(params) {
+    return this.request("GET", "/refunds/aggregate", { query: params });
+  }
+  /** Get refund aggregates (profile-scoped). `GET /refunds/profile/aggregate` */
+  async aggregateByProfile(params) {
+    return this.request("GET", "/refunds/profile/aggregate", { query: params });
+  }
+  /** Manually update refund status. `PUT /refunds/{refundId}/manual-update` */
+  async manualUpdate(refundId, params) {
+    return this.request("PUT", `/refunds/${encodeURIComponent(refundId)}/manual-update`, {
+      body: params
+    });
+  }
+};
+
+// src/resources/relay.ts
+var Relay = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async create(params) {
+    return this.request("POST", "/relay", { body: params });
+  }
+  async retrieve(relayId) {
+    return this.request("GET", `/relay/${encodeURIComponent(relayId)}`);
+  }
+};
+
+// src/resources/routing.ts
+var Routing = class {
+  constructor(request) {
+    this.request = request;
+    this.decision = new RoutingDecisionManager(request);
+  }
+  /**
+   * Create a new routing algorithm.
+   *
+   * @param params - Routing algorithm definition (rule-based, priority, or volume-based).
+   * @returns The created routing configuration.
+   *
+   * @example
+   * ```typescript
+   * const config = await delopay.routing.create({
+   *   name: 'EU Priority',
+   *   algorithm: { type: 'priority', data: [{ connector: 'stripe' }] },
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.request("POST", "/routing", { body: params });
+  }
+  /**
+   * Retrieve a routing algorithm by its ID.
+   *
+   * @param algorithmId - The routing algorithm ID.
+   * @returns The routing configuration.
+   */
+  async retrieve(algorithmId) {
+    return this.request("GET", `/routing/${encodeURIComponent(algorithmId)}`);
+  }
+  /**
+   * Activate a routing algorithm, making it the active routing strategy for the shop.
+   *
+   * @param algorithmId - The routing algorithm ID to activate.
+   * @returns The activated routing configuration.
+   */
+  async activate(algorithmId) {
+    return this.request("POST", `/routing/${encodeURIComponent(algorithmId)}/activate`);
+  }
+  /**
+   * Deactivate the currently active routing algorithm (falls back to default routing).
+   *
+   * @returns The deactivated routing configuration.
+   */
+  async deactivate() {
+    return this.request("POST", "/routing/deactivate");
+  }
+  /**
+   * List all routing algorithms for the current shop.
+   *
+   * @returns Array of routing configurations.
+   */
+  async list() {
+    return this.request("GET", "/routing");
+  }
+  // --- Advanced operations (Task 3.4) ---
+  /** Get active routing config. `GET /routing/active` */
+  async getActive() {
+    return this.request("GET", "/routing/active");
+  }
+  /** Update default routing config. `POST /routing/default` */
+  async updateDefault(params) {
+    return this.request("POST", "/routing/default", { body: params });
+  }
+  /** Retrieve default config for profiles. `GET /routing/default/profile` */
+  async getDefaultProfile() {
+    return this.request("GET", "/routing/default/profile");
+  }
+  /** Update default config for a profile. `POST /routing/default/profile/{profileId}` */
+  async updateDefaultProfile(profileId, params) {
+    return this.request("POST", `/routing/default/profile/${encodeURIComponent(profileId)}`, {
+      body: params
+    });
+  }
+  /** List routing configs for profile. `GET /routing/list/profile` */
+  async listForProfile() {
+    return this.request("GET", "/routing/list/profile");
+  }
+  /** Evaluate a routing rule. `POST /routing/rule/evaluate` */
+  async evaluateRule(params) {
+    return this.request("POST", "/routing/rule/evaluate", { body: params });
+  }
+  /** Migrate routing rules for profile. `POST /routing/rule/migrate` */
+  async migrateRule(params) {
+    return this.request("POST", "/routing/rule/migrate", { body: params });
+  }
+  /** Evaluate routing for a payment. `POST /routing/evaluate` */
+  async evaluate(params) {
+    return this.request("POST", "/routing/evaluate", { body: params });
+  }
+  /** Update gateway scores for dynamic routing. `POST /routing/feedback` */
+  async feedback(params) {
+    return this.request("POST", "/routing/feedback", { body: params });
+  }
+};
+var RoutingDecisionManager = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Upsert decision manager config. `PUT /routing/decision` */
+  async upsert(params) {
+    return this.request("PUT", "/routing/decision", { body: params });
+  }
+  /** Retrieve decision manager config. `GET /routing/decision` */
+  async retrieve() {
+    return this.request("GET", "/routing/decision");
+  }
+  /** Delete decision manager config. `DELETE /routing/decision` */
+  async delete() {
+    return this.request("DELETE", "/routing/decision");
+  }
+  /** Upsert surcharge decision config. `PUT /routing/decision/surcharge` */
+  async upsertSurcharge(params) {
+    return this.request("PUT", "/routing/decision/surcharge", { body: params });
+  }
+  /** Retrieve surcharge decision config. `GET /routing/decision/surcharge` */
+  async retrieveSurcharge() {
+    return this.request("GET", "/routing/decision/surcharge");
+  }
+  /** Delete surcharge decision config. `DELETE /routing/decision/surcharge` */
+  async deleteSurcharge() {
+    return this.request("DELETE", "/routing/decision/surcharge");
+  }
+};
+
+// src/resources/shops.ts
+var ShopGateways = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Connect a payment gateway to a shop.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param shopId - The shop (business profile) ID.
+   * @param params - Gateway connector credentials and configuration.
+   * @returns The created gateway connection.
+   */
+  async connect(merchantId, shopId, params) {
+    return this.request(
+      "POST",
+      `/shops/${encodeURIComponent(merchantId)}/${encodeURIComponent(shopId)}/gateways`,
+      { body: params }
+    );
+  }
+  /**
+   * List all gateway connections for a shop.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param shopId - The shop ID.
+   * @returns Array of gateway connections.
+   */
+  async list(merchantId, shopId) {
+    return this.request(
+      "GET",
+      `/shops/${encodeURIComponent(merchantId)}/${encodeURIComponent(shopId)}/gateways`
+    );
+  }
+  /**
+   * Disconnect a gateway from a shop.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param shopId - The shop ID.
+   * @param gatewayId - The gateway connector ID to remove.
+   * @returns The removed gateway connection.
+   */
+  async disconnect(merchantId, shopId, gatewayId) {
+    return this.request(
+      "DELETE",
+      `/shops/${encodeURIComponent(merchantId)}/${encodeURIComponent(shopId)}/gateways/${encodeURIComponent(gatewayId)}`
+    );
+  }
+};
+var Shops = class {
+  constructor(request) {
+    this.request = request;
+    this.gateways = new ShopGateways(request);
+  }
+  /**
+   * Create a new shop under a merchant account.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param params - Shop creation parameters (name, etc.).
+   * @returns The created shop.
+   *
+   * @example
+   * ```typescript
+   * const shop = await delopay.shops.create('merch_123', { profile_name: 'EU Store' });
+   * ```
+   */
+  async create(merchantId, params) {
+    return this.request("POST", `/shops/${encodeURIComponent(merchantId)}`, { body: params });
+  }
+  /**
+   * Retrieve a shop by its ID.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param shopId - The shop ID.
+   * @returns The shop.
+   */
+  async retrieve(merchantId, shopId) {
+    return this.request(
+      "GET",
+      `/shops/${encodeURIComponent(merchantId)}/${encodeURIComponent(shopId)}`
+    );
+  }
+  /**
+   * Update a shop's configuration.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param shopId - The shop ID to update.
+   * @param params - Fields to update.
+   * @returns The updated shop.
+   */
+  async update(merchantId, shopId, params) {
+    return this.request(
+      "PUT",
+      `/shops/${encodeURIComponent(merchantId)}/${encodeURIComponent(shopId)}`,
+      { body: params }
+    );
+  }
+  /**
+   * Delete a shop.
+   *
+   * @param merchantId - The merchant account ID.
+   * @param shopId - The shop ID to delete.
+   * @returns The deleted shop object.
+   */
+  async delete(merchantId, shopId) {
+    return this.request(
+      "DELETE",
+      `/shops/${encodeURIComponent(merchantId)}/${encodeURIComponent(shopId)}`
+    );
+  }
+  /**
+   * List all shops under a merchant account.
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns Array of shops.
+   */
+  async list(merchantId) {
+    return this.request("GET", `/shops/${encodeURIComponent(merchantId)}`);
+  }
+};
+
+// src/resources/stripeConnect.ts
+var StripeConnect = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async createAccount(params) {
+    return this.request("POST", "/connector_onboarding/stripe/accounts", { body: params });
+  }
+  async createAccountLink(params) {
+    return this.request("POST", "/connector_onboarding/stripe/account_links", { body: params });
+  }
+  // --- Generic connector onboarding (Task 4.11) ---
+  /** Get onboarding action URL. `POST /connector_onboarding/action_url` */
+  async getActionUrl(params) {
+    return this.request("POST", "/connector_onboarding/action_url", { body: params });
+  }
+  /** Sync onboarding status. `POST /connector_onboarding/sync` */
+  async syncOnboarding(params) {
+    return this.request("POST", "/connector_onboarding/sync", { body: params });
+  }
+  /** Reset tracking ID. `POST /connector_onboarding/reset_tracking_id` */
+  async resetTrackingId(params) {
+    return this.request("POST", "/connector_onboarding/reset_tracking_id", { body: params });
+  }
+};
+
+// src/resources/threeDsRules.ts
+var ThreeDsRules = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async execute(params) {
+    return this.request("POST", "/three_ds_decision/execute", { body: params });
+  }
+};
+
+// src/resources/users.ts
+var Users = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async signUp(params) {
+    return this.request("POST", "/user/signup", { body: params });
+  }
+  async signIn(params) {
+    return this.request("POST", "/user/signin", { body: params });
+  }
+  async signOut() {
+    return this.request("POST", "/user/signout");
+  }
+  async getDetails() {
+    return this.request("GET", "/user");
+  }
+  async update(params) {
+    return this.request("POST", "/user/update", { body: params });
+  }
+  async changePassword(params) {
+    return this.request("POST", "/user/change_password", { body: params });
+  }
+  async rotatePassword(params) {
+    return this.request("POST", "/user/rotate_password", { body: params });
+  }
+  async forgotPassword(params) {
+    return this.request("POST", "/user/forgot_password", { body: params });
+  }
+  /**
+   * Commit a password reset.
+   *
+   * The caller is responsible for obtaining a `SinglePurposeToken` with
+   * `purpose: reset_password` via the email-token exchange + TOTP flow
+   * (see `fromEmail`, `beginTotp`, `updateTotp`/`verifyTotp`,
+   * `generateRecoveryCodes`, `terminate2fa`) and setting it on the client
+   * via `setJwtToken` before calling this method. `body.token` must still
+   * be the original `EmailToken` from the reset-link URL — the handler
+   * decodes it a second time to find the user.
+   */
+  async resetPassword(params) {
+    return this.request("POST", "/user/reset_password", { body: params });
+  }
+  /**
+   * Exchange an email-link token (`EmailToken`) for a single-purpose JWT
+   * that drives the next step of the flow (TOTP, verify email, accept
+   * invitation, etc.). No authentication required.
+   *
+   * The `token_type` in the response tells you which step to run next.
+   */
+  async fromEmail(params) {
+    return this.request("POST", "/user/from_email", { body: params });
+  }
+  async verifyEmail(params) {
+    return this.request("POST", "/user/verify_email", { body: params });
+  }
+  async sendVerificationEmail(params) {
+    return this.request("POST", "/user/verify_email_request", { body: params });
+  }
+  async createMerchant(params) {
+    return this.request("POST", "/user/create_merchant", { body: params });
+  }
+  async switchMerchant(params) {
+    return this.request("POST", "/user/switch/merchant", { body: params });
+  }
+  async switchProfile(params) {
+    return this.request("POST", "/user/switch/profile", { body: params });
+  }
+  async listMerchants() {
+    return this.request("GET", "/user/list/merchant");
+  }
+  async listProfiles() {
+    return this.request("GET", "/user/list/profile");
+  }
+  async inviteUsers(params) {
+    return this.request("POST", "/user/user/invite_multiple", { body: params });
+  }
+  async acceptInvitation(params) {
+    return this.request("POST", "/user/user/invite/accept", { body: params });
+  }
+  /**
+   * Start TOTP setup (or no-op if already set).
+   *
+   * Returns the QR-code payload when the user has no TOTP configured yet;
+   * returns `{ secret: null }` when the user is already set up (caller
+   * should then prompt for a 6-digit code and call `verifyTotp`).
+   *
+   * Requires `Authorization: Bearer <SPT{purpose:totp}>`.
+   */
+  async beginTotp() {
+    return this.request("GET", "/user/2fa/totp/begin");
+  }
+  /**
+   * Verify a 6-digit TOTP code for a user whose TOTP is already set up.
+   * Marks the code as used in Redis so subsequent flow steps can advance.
+   *
+   * Requires `Authorization: Bearer <SPT{purpose:totp}>`.
+   */
+  async verifyTotp(params) {
+    return this.request("POST", "/user/2fa/totp/verify", { body: params });
+  }
+  async resetTotp() {
+    return this.request("GET", "/user/2fa/totp/reset");
+  }
+  async generateRecoveryCodes() {
+    return this.request("GET", "/user/2fa/recovery_code/generate");
+  }
+  async verifyRecoveryCode(params) {
+    return this.request("POST", "/user/2fa/recovery_code/verify", { body: params });
+  }
+  async sendPhoneOtp(params) {
+    return this.request("POST", "/user/phone/send-otp", { body: params });
+  }
+  async verifyPhoneOtp(params) {
+    return this.request("POST", "/user/phone/verify-otp", { body: params });
+  }
+  async getRoleFromToken() {
+    return this.request("GET", "/user/role");
+  }
+  async listRoles() {
+    return this.request("GET", "/user/role/list");
+  }
+  async listUserRoles(params) {
+    return this.request("POST", "/user/user", { body: params });
+  }
+  async updateUserRole(params) {
+    return this.request("POST", "/user/user/update_role", { body: params });
+  }
+  async deleteUserRole(params) {
+    return this.request("DELETE", "/user/user/delete", { body: params });
+  }
+  // --- Advanced methods (Task 4.7) ---
+  /** Sign in (v2). `POST /user/v2/signin` */
+  async signInV2(params) {
+    return this.request("POST", "/user/v2/signin", { body: params });
+  }
+  /** Sign in via OIDC. `POST /user/oidc` */
+  async signInOidc(params) {
+    return this.request("POST", "/user/oidc", { body: params });
+  }
+  /** Transfer key. `POST /user/key/transfer` */
+  async transferKey(params) {
+    return this.request("POST", "/user/key/transfer", { body: params });
+  }
+  /** List invitations. `GET /user/list/invitation` */
+  async listInvitations() {
+    return this.request("GET", "/user/list/invitation");
+  }
+  /** Check 2FA status. `GET /user/2fa` */
+  async check2faStatus() {
+    return this.request("GET", "/user/2fa");
+  }
+  /** Check 2FA status (v2). `GET /user/2fa/v2` */
+  async check2faStatusV2() {
+    return this.request("GET", "/user/2fa/v2");
+  }
+  /**
+   * Finish first-time TOTP setup: commit the secret generated by `beginTotp`
+   * against a 6-digit code from the user's authenticator app.
+   *
+   * `PUT /user/2fa/totp/verify`. Requires `Authorization: Bearer <SPT{purpose:totp}>`.
+   */
+  async updateTotp(params) {
+    return this.request("PUT", "/user/2fa/totp/verify", { body: params });
+  }
+  /**
+   * Complete the TOTP step and advance to the next flow stage (e.g.
+   * `reset_password`). Returns a fresh single-purpose token with the
+   * next `token_type`.
+   *
+   * `GET /user/2fa/terminate`. Requires `Authorization: Bearer <SPT{purpose:totp}>`.
+   */
+  async terminate2fa(query) {
+    if (query === void 0) {
+      return this.request("GET", "/user/2fa/terminate");
+    }
+    return this.request("GET", "/user/2fa/terminate", {
+      query
+    });
+  }
+  /** Create auth method. `POST /user/auth` */
+  async createAuthMethod(params) {
+    return this.request("POST", "/user/auth", { body: params });
+  }
+  /** Update auth method. `PUT /user/auth` */
+  async updateAuthMethod(params) {
+    return this.request("PUT", "/user/auth", { body: params });
+  }
+  /** List auth methods. `GET /user/auth/list` */
+  async listAuthMethods() {
+    return this.request("GET", "/user/auth/list");
+  }
+  /** Get auth URL. `GET /user/auth/url` */
+  async getAuthUrl() {
+    return this.request("GET", "/user/auth/url");
+  }
+  /** Select auth method. `POST /user/auth/select` */
+  async selectAuth(params) {
+    return this.request("POST", "/user/auth/select", { body: params });
+  }
+  /** List user roles (v2). `POST /user/user/v2` */
+  async listUserRolesV2(params) {
+    return this.request("POST", "/user/user/v2", { body: params });
+  }
+  /** List users in lineage. `GET /user/user/list` */
+  async listUsersInLineage() {
+    return this.request("GET", "/user/user/list");
+  }
+  /** List users in lineage (v2). `GET /user/user/v2/list` */
+  async listUsersInLineageV2() {
+    return this.request("GET", "/user/user/v2/list");
+  }
+  /** Accept invitation (v2). `POST /user/user/invite/accept/v2` */
+  async acceptInvitationV2(params) {
+    return this.request("POST", "/user/user/invite/accept/v2", { body: params });
+  }
+  /** Resend invite. `POST /user/user/resend_invite` */
+  async resendInvite(params) {
+    return this.request("POST", "/user/user/resend_invite", { body: params });
+  }
+  /** Get role (v2). `GET /user/role/v2` */
+  async getRoleV2() {
+    return this.request("GET", "/user/role/v2");
+  }
+  /** Get role (v3). `GET /user/role/v3` */
+  async getRoleV3() {
+    return this.request("GET", "/user/role/v3");
+  }
+  /** List roles (v2). `GET /user/role/v2/list` */
+  async listRolesV2() {
+    return this.request("GET", "/user/role/v2/list");
+  }
+  /** List invitable roles. `GET /user/role/list/invite` */
+  async listInvitableRoles() {
+    return this.request("GET", "/user/role/list/invite");
+  }
+  /** List updatable roles. `GET /user/role/list/update` */
+  async listUpdatableRoles() {
+    return this.request("GET", "/user/role/list/update");
+  }
+  /** Get permission info. `GET /user/permission_info` */
+  async getPermissionInfo() {
+    return this.request("GET", "/user/permission_info");
+  }
+  /** Get module list. `GET /user/module/list` */
+  async getModuleList() {
+    return this.request("GET", "/user/module/list");
+  }
+  /** Get parent list. `GET /user/parent/list` */
+  async getParentList() {
+    return this.request("GET", "/user/parent/list");
+  }
+  /** Create a role. `POST /user/role` */
+  async createRole(params) {
+    return this.request("POST", "/user/role", { body: params });
+  }
+  /** Get role by ID. `GET /user/role/{roleId}` */
+  async getRoleById(roleId) {
+    return this.request("GET", `/user/role/${encodeURIComponent(roleId)}`);
+  }
+  /** Update role by ID. `PUT /user/role/{roleId}` */
+  async updateRole(roleId, params) {
+    return this.request("PUT", `/user/role/${encodeURIComponent(roleId)}`, { body: params });
+  }
+};
+
+// src/resources/verification.ts
+var Verification = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async registerApplePayDomains(merchantId, params) {
+    return this.request("POST", `/verify/apple_pay/${encodeURIComponent(merchantId)}`, {
+      body: params
+    });
+  }
+  async getApplePayVerifiedDomains(params) {
+    return this.request("GET", "/verify/applepay_verified_domains", {
+      query: params
+    });
+  }
+};
+
+// src/resources/webhooks.ts
+function hexToBytes(hex) {
+  if (hex.length === 0 || hex.length % 2 !== 0) return null;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    const byte = Number.parseInt(hex.slice(i, i + 2), 16);
+    if (Number.isNaN(byte)) return null;
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+var Webhooks = {
+  /**
+   * Verify the signature of an incoming Delopay webhook and return the parsed event.
+   *
+   * Uses the Web Crypto API (`globalThis.crypto.subtle`), so it runs unchanged in
+   * Node 18+, modern browsers, Deno, Bun, and edge runtimes (Cloudflare Workers, Vercel Edge).
+   *
+   * This method is available as a static property on the `Delopay` class
+   * (`Delopay.webhooks.verify`) and does not require a client instance.
+   *
+   * @param rawBody - The raw request body string (do **not** parse it before passing).
+   * @param signatureHeader - The value of the `delopay-signature` HTTP header.
+   * @param secret - Your webhook signing secret from the Delopay dashboard.
+   * @param options - Optional verification settings (replay tolerance).
+   * @returns Promise that resolves to the parsed webhook event.
+   * @throws {Error} When the signature is invalid, the timestamp is missing, or the event is too old.
+   *
+   * @example
+   * ```typescript
+   * // Express example
+   * app.post('/webhook', express.raw({ type: 'application/json' }), async (req, res) => {
+   *   const event = await Delopay.webhooks.verify(
+   *     req.body.toString(),
+   *     req.headers['delopay-signature'] as string,
+   *     process.env.DELOPAY_WEBHOOK_SECRET!,
+   *   );
+   *   console.log(event.type, event.data);
+   *   res.sendStatus(200);
+   * });
+   * ```
+   */
+  async verify(rawBody, signatureHeader, secret, options) {
+    const tolerance = options?.tolerance ?? 300;
+    const parts = signatureHeader.split(",");
+    const timestampPart = parts.find((p) => p.startsWith("t="));
+    const signaturePart = parts.find((p) => p.startsWith("v1="));
+    if (!timestampPart || !signaturePart) {
+      throw new Error("Invalid webhook signature format");
+    }
+    const timestamp = Number.parseInt(timestampPart.slice(2), 10);
+    if (!Number.isFinite(timestamp)) {
+      throw new Error("Invalid webhook timestamp");
+    }
+    const signatureHex = signaturePart.slice(3);
+    const signatureBytes = hexToBytes(signatureHex);
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+      throw new Error(
+        "Web Crypto unavailable: Delopay.webhooks.verify requires globalThis.crypto.subtle (Node 18+, modern browsers, Workers, Deno)"
+      );
+    }
+    const encoder = new TextEncoder();
+    const asBufferSource = (bytes) => bytes;
+    const key = await subtle.importKey(
+      "raw",
+      asBufferSource(encoder.encode(secret)),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+    const signedPayload = asBufferSource(encoder.encode(`${timestamp}.${rawBody}`));
+    const signaturesMatch = signatureBytes !== null && await subtle.verify("HMAC", key, asBufferSource(signatureBytes), signedPayload);
+    if (!signaturesMatch) {
+      throw new Error("Invalid webhook signature");
+    }
+    const age = Math.floor(Date.now() / 1e3) - timestamp;
+    if (Math.abs(age) > tolerance) {
+      throw new Error("Webhook timestamp too old");
+    }
+    return JSON.parse(rawBody);
+  }
+};
+
+// src/resources/analytics.ts
+var AnalyticsDomain = class {
+  constructor(request, domain) {
+    this.request = request;
+    this.domain = domain;
+  }
+  /** Get metrics. `POST /analytics/v1/metrics/{domain}` */
+  async metrics(params, scope) {
+    const prefix = scope ? `/analytics/v1/${scope}` : "/analytics/v1";
+    return this.request("POST", `${prefix}/metrics/${encodeURIComponent(this.domain)}`, {
+      body: [params]
+    });
+  }
+  /** Get filters. `POST /analytics/v1/filters/{domain}` */
+  async filters(params, scope) {
+    const prefix = scope ? `/analytics/v1/${scope}` : "/analytics/v1";
+    return this.request("POST", `${prefix}/filters/${encodeURIComponent(this.domain)}`, {
+      body: params
+    });
+  }
+  /** Generate report. `POST /analytics/v1/report/{domain}` */
+  async report(params, scope) {
+    const prefix = scope ? `/analytics/v1/${scope}` : "/analytics/v1";
+    return this.request("POST", `${prefix}/report/${encodeURIComponent(this.domain)}`, {
+      body: params
+    });
+  }
+  /** Sankey chart data. `POST /analytics/v1/metrics/{domain}/sankey` */
+  async sankey(params, scope) {
+    const prefix = scope ? `/analytics/v1/${scope}` : "/analytics/v1";
+    return this.request("POST", `${prefix}/metrics/${encodeURIComponent(this.domain)}/sankey`, {
+      body: params
+    });
+  }
+};
+var Analytics = class {
+  constructor(request) {
+    this.request = request;
+    this.payments = new AnalyticsDomain(request, "payments");
+    this.refunds = new AnalyticsDomain(request, "refunds");
+    this.disputes = new AnalyticsDomain(request, "disputes");
+    this.authEvents = new AnalyticsDomain(request, "auth_events");
+    this.sdkEvents = new AnalyticsDomain(request, "sdk_events");
+    this.frm = new AnalyticsDomain(request, "frm");
+    this.apiEvents = new AnalyticsDomain(request, "api_events");
+    this.routing = new AnalyticsDomain(request, "routing");
+  }
+  /** Global search. `POST /analytics/v1/search` */
+  async search(params) {
+    return this.request("POST", "/analytics/v1/search", { body: params });
+  }
+  /** Domain-specific search. `POST /analytics/v1/search/{domain}` */
+  async searchDomain(domain, params) {
+    return this.request("POST", `/analytics/v1/search/${encodeURIComponent(domain)}`, {
+      body: params
+    });
+  }
+  /** Get analytics info. `GET /analytics/v1/{domain}/info` */
+  async getInfo(domain) {
+    return this.request("GET", `/analytics/v1/${encodeURIComponent(domain)}/info`);
+  }
+  /** Get API event logs. `GET /analytics/v1/api_event_logs` */
+  async apiEventLogs(params) {
+    return this.request("GET", "/analytics/v1/api_event_logs", { query: params });
+  }
+  /** Get SDK event logs. `POST /analytics/v1/sdk_event_logs` */
+  async sdkEventLogs(params) {
+    return this.request("POST", "/analytics/v1/sdk_event_logs", { body: params });
+  }
+  /** Get connector event logs. `GET /analytics/v1/connector_event_logs` */
+  async connectorEventLogs(params) {
+    return this.request("GET", "/analytics/v1/connector_event_logs", { query: params });
+  }
+  /** Get routing event logs. `GET /analytics/v1/routing_event_logs` */
+  async routingEventLogs(params) {
+    return this.request("GET", "/analytics/v1/routing_event_logs", { query: params });
+  }
+  /** Get outgoing webhook event logs. `GET /analytics/v1/outgoing_webhook_event_logs` */
+  async outgoingWebhookEventLogs(params) {
+    return this.request("GET", "/analytics/v1/outgoing_webhook_event_logs", { query: params });
+  }
+};
+
+// src/resources/analyticsDashboard.ts
+var AnalyticsDashboard = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Get analytics dashboard data. `GET /analytics-dashboard` */
+  async retrieve(params) {
+    return this.request("GET", "/analytics-dashboard", { query: params });
+  }
+  /** Generate analytics dashboard report. `POST /analytics-dashboard` */
+  async generate(params) {
+    return this.request("POST", "/analytics-dashboard", { body: params });
+  }
+};
+
+// src/resources/cache.ts
+var Cache = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Invalidate a cache entry by key. `POST /cache/invalidate/{key}` */
+  async invalidate(key) {
+    return this.request("POST", `/cache/invalidate/${encodeURIComponent(key)}`);
+  }
+};
+
+// src/resources/cards.ts
+var Cards = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Create a card. `POST /cards/create` */
+  async create(params) {
+    return this.request("POST", "/cards/create", { body: params });
+  }
+  /** Update a card. `POST /cards/update` */
+  async update(params) {
+    return this.request("POST", "/cards/update", { body: params });
+  }
+  /** Retrieve card info by BIN. `GET /cards/{bin}` */
+  async retrieve(bin) {
+    return this.request("GET", `/cards/${encodeURIComponent(bin)}`);
+  }
+};
+
+// src/resources/configs.ts
+var Configs = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Create a config. `POST /configs` */
+  async create(params) {
+    return this.request("POST", "/configs", { body: params });
+  }
+  /** Retrieve a config by key. `GET /configs/{key}` */
+  async retrieve(key) {
+    return this.request("GET", `/configs/${encodeURIComponent(key)}`);
+  }
+  /** Update a config. `PUT /configs/{key}` */
+  async update(key, params) {
+    return this.request("PUT", `/configs/${encodeURIComponent(key)}`, { body: params });
+  }
+  /** Delete a config. `DELETE /configs/{key}` */
+  async delete(key) {
+    return this.request("DELETE", `/configs/${encodeURIComponent(key)}`);
+  }
+};
+
+// src/resources/export.ts
+var Export = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Export transactions. `POST /export/transactions` */
+  async transactions(params) {
+    return this.request("POST", "/export/transactions", { body: params });
+  }
+};
+
+// src/resources/featureMatrix.ts
+var FeatureMatrix = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Retrieve the feature matrix. `GET /feature_matrix` */
+  async retrieve() {
+    return this.request("GET", "/feature_matrix");
+  }
+};
+
+// src/resources/files.ts
+var Files = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Upload a file. `POST /files` */
+  async create(params) {
+    return this.request("POST", "/files", { body: params });
+  }
+  /** Retrieve/download a file. `GET /files/{fileId}` */
+  async retrieve(fileId) {
+    return this.request("GET", `/files/${encodeURIComponent(fileId)}`);
+  }
+  /** Delete a file. `DELETE /files/{fileId}` */
+  async delete(fileId) {
+    return this.request("DELETE", `/files/${encodeURIComponent(fileId)}`);
+  }
+};
+
+// src/resources/forex.ts
+var Forex = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Retrieve forex rates. `GET /forex/rates` */
+  async getRates(params) {
+    return this.request("GET", "/forex/rates", { query: params });
+  }
+  /** Convert from minor currency. `GET /forex/convert_from_minor` */
+  async convertFromMinor(params) {
+    return this.request("GET", "/forex/convert_from_minor", { query: params });
+  }
+};
+
+// src/resources/regions.ts
+var Regions = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Create a region. `POST /regions` */
+  async create(params) {
+    return this.request("POST", "/regions", { body: params });
+  }
+  /** Retrieve a region by ID. `GET /regions/{regionId}` */
+  async retrieve(regionId) {
+    return this.request("GET", `/regions/${encodeURIComponent(regionId)}`);
+  }
+  /** Update a region. `PUT /regions/{regionId}` */
+  async update(regionId, params) {
+    return this.request("PUT", `/regions/${encodeURIComponent(regionId)}`, { body: params });
+  }
+  /** Delete a region. `DELETE /regions/{regionId}` */
+  async delete(regionId) {
+    return this.request("DELETE", `/regions/${encodeURIComponent(regionId)}`);
+  }
+  /** List all regions. `GET /regions/list` */
+  async list() {
+    return this.request("GET", "/regions/list");
+  }
+};
+
+// src/resources/subscriptions.ts
+var Subscriptions = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Create and immediately confirm a subscription. `POST /subscriptions` */
+  async createAndConfirm(params) {
+    return this.request("POST", "/subscriptions", { body: params });
+  }
+  /** Create a subscription (without confirming). `POST /subscriptions/create` */
+  async create(params) {
+    return this.request("POST", "/subscriptions/create", { body: params });
+  }
+  /** Retrieve a subscription by ID. `GET /subscriptions/{subscriptionId}` */
+  async retrieve(subscriptionId) {
+    return this.request("GET", `/subscriptions/${encodeURIComponent(subscriptionId)}`);
+  }
+  /** Confirm a subscription. `POST /subscriptions/{subscriptionId}/confirm` */
+  async confirm(subscriptionId, params) {
+    return this.request("POST", `/subscriptions/${encodeURIComponent(subscriptionId)}/confirm`, {
+      body: params
+    });
+  }
+  /** Update a subscription. `PUT /subscriptions/{subscriptionId}/update` */
+  async update(subscriptionId, params) {
+    return this.request("PUT", `/subscriptions/${encodeURIComponent(subscriptionId)}/update`, {
+      body: params
+    });
+  }
+  /** List subscriptions. `GET /subscriptions/list` */
+  async list(params) {
+    return this.request("GET", "/subscriptions/list", {
+      query: params
+    });
+  }
+  /** Get subscription estimate. `GET /subscriptions/estimate` */
+  async getEstimate(params) {
+    return this.request("GET", "/subscriptions/estimate", { query: params });
+  }
+  /** Get subscription items. `GET /subscriptions/items` */
+  async getItems(params) {
+    return this.request("GET", "/subscriptions/items", { query: params });
+  }
+  /** Pause a subscription. `POST /subscriptions/{subscriptionId}/pause` */
+  async pause(subscriptionId) {
+    return this.request("POST", `/subscriptions/${encodeURIComponent(subscriptionId)}/pause`);
+  }
+  /** Resume a subscription. `POST /subscriptions/{subscriptionId}/resume` */
+  async resume(subscriptionId) {
+    return this.request("POST", `/subscriptions/${encodeURIComponent(subscriptionId)}/resume`);
+  }
+  /** Cancel a subscription. `POST /subscriptions/{subscriptionId}/cancel` */
+  async cancel(subscriptionId) {
+    return this.request("POST", `/subscriptions/${encodeURIComponent(subscriptionId)}/cancel`);
+  }
+};
+
+// src/client.ts
+var PRODUCTION_URL = "https://api.delopay.net";
+var SANDBOX_URL = "https://sandbox.delopay.net";
+var MAX_RAW_BODY_BYTES = 2048;
+var MAX_RETRY_AFTER_MS = 3e4;
+function parseRetryAfter(header) {
+  if (!header) return null;
+  const trimmed = header.trim();
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS);
+  }
+  const date = Date.parse(trimmed);
+  if (Number.isFinite(date)) {
+    const delta = date - Date.now();
+    return delta > 0 ? Math.min(delta, MAX_RETRY_AFTER_MS) : 0;
+  }
+  return null;
+}
+function truncateRawBody(raw) {
+  if (!raw) return void 0;
+  return raw.length > MAX_RAW_BODY_BYTES ? raw.slice(0, MAX_RAW_BODY_BYTES) + "\u2026" : raw;
+}
+function findIdempotencyKey(headers) {
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === "idempotency-key") return v;
+  }
+  return void 0;
+}
+function noop() {
+}
+function combineSignals(signals) {
+  const controller = new AbortController();
+  const listeners = [];
+  const dispose = () => {
+    for (const { signal, handler } of listeners) {
+      signal.removeEventListener("abort", handler);
+    }
+    listeners.length = 0;
+  };
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      dispose();
+      return { signal: controller.signal, dispose: noop };
+    }
+    const handler = () => {
+      controller.abort(signal.reason);
+      dispose();
+    };
+    signal.addEventListener("abort", handler, { once: true });
+    listeners.push({ signal, handler });
+  }
+  return { signal: controller.signal, dispose };
+}
+var SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "client_secret",
+  "ephemeral_key",
+  "api_key",
+  "publishable_key"
+]);
+function redactUrlForLogging(url) {
+  const qIdx = url.indexOf("?");
+  if (qIdx === -1) return url;
+  const base = url.slice(0, qIdx);
+  const query = url.slice(qIdx + 1);
+  const parts = query.split("&").map((pair) => {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx === -1) return pair;
+    const key = pair.slice(0, eqIdx);
+    if (SENSITIVE_QUERY_KEYS.has(decodeURIComponent(key).toLowerCase())) {
+      return `${key}=REDACTED`;
+    }
+    return pair;
+  });
+  return `${base}?${parts.join("&")}`;
+}
+var Delopay = class {
+  /**
+   * Create a new Delopay client.
+   *
+   * @param apiKey - Your Delopay API key (e.g. `sk_live_...` or `sk_test_...`).
+   *   Pass an empty string or omit for JWT-only usage (e.g. dashboard apps).
+   * @param options - Optional configuration (sandbox mode, base URL override, timeout).
+   */
+  constructor(apiKey, options) {
+    this.apiKey = apiKey ?? "";
+    this.timeout = options?.timeout ?? 3e4;
+    this.maxRetries = options?.maxRetries ?? 2;
+    this.debug = options?.debug ?? false;
+    if (options?.logger !== void 0) this.logger = options.logger;
+    if (options?.baseUrl !== void 0) {
+      this.baseUrl = options.baseUrl;
+    } else if (options?.sandbox) {
+      this.baseUrl = SANDBOX_URL;
+    } else {
+      this.baseUrl = PRODUCTION_URL;
+    }
+    const request = this.request.bind(this);
+    this.payments = new Payments(request);
+    this.refunds = new Refunds(request);
+    this.customers = new Customers(request);
+    this.paymentMethods = new PaymentMethods(request);
+    this.paymentLinks = new PaymentLinks(request);
+    this.mandates = new Mandates(request);
+    this.disputes = new Disputes(request);
+    this.payouts = new Payouts(request);
+    this.ephemeralKeys = new EphemeralKeys(request);
+    this.events = new Events(request);
+    this.poll = new Poll(request);
+    this.connectors = new Connectors(request);
+    this.routing = new Routing(request);
+    this.profiles = new Profiles(request);
+    this.shops = new Shops(request);
+    this.profileAcquirers = new ProfileAcquirers(request);
+    this.authentication = new Authentication(request);
+    this.verification = new Verification(request);
+    this.users = new Users(request);
+    this.apiKeys = new ApiKeys(request);
+    this.billing = new Billing(request);
+    this.blocklist = new Blocklist(request);
+    this.cardIssuers = new CardIssuers(request);
+    this.fees = new Fees(request);
+    this.gsm = new Gsm(request);
+    this.merchantAccounts = new MerchantAccounts(request);
+    this.projects = new Projects(request);
+    this.relay = new Relay(request);
+    this.stripeConnect = new StripeConnect(request);
+    this.threeDsRules = new ThreeDsRules(request);
+    this.subscriptions = new Subscriptions(request);
+    this.files = new Files(request);
+    this.export = new Export(request);
+    this.forex = new Forex(request);
+    this.regions = new Regions(request);
+    this.analytics = new Analytics(request);
+    this.analyticsDashboard = new AnalyticsDashboard(request);
+    this.featureMatrix = new FeatureMatrix(request);
+    this.cards = new Cards(request);
+    this.configs = new Configs(request);
+    this.cache = new Cache(request);
+  }
+  /**
+   * Set a JWT token for subsequent requests.
+   * When set, requests use `Authorization: Bearer <token>` instead of `api-key`.
+   * Useful after `users.signIn()` returns a JWT for dashboard operations.
+   */
+  setJwtToken(token) {
+    this.jwtToken = token;
+  }
+  /**
+   * Clear the JWT token, reverting to API key authentication.
+   */
+  clearJwtToken() {
+    this.jwtToken = void 0;
+  }
+  /**
+   * Make a raw HTTP request to the Delopay API.
+   *
+   * You rarely need to call this directly — prefer the typed resource methods.
+   * Use it only for endpoints not yet covered by a resource class.
+   *
+   * @param method - HTTP method (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`).
+   * @param path - API path starting with `/` (e.g. `/payments`).
+   * @param options - Optional body, query parameters, and headers.
+   * @returns Parsed JSON response body typed as `T`.
+   * @throws {DelopayAuthenticationError} On 401 responses.
+   * @throws {DelopayError} On all other non-2xx responses, timeouts, and network errors.
+   */
+  async request(method, path, options) {
+    let url = `${this.baseUrl}${path}`;
+    if (options?.query) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value === void 0 || value === null) continue;
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            if (v !== void 0 && v !== null) params.append(key, String(v));
+          }
+        } else {
+          params.set(key, String(value));
+        }
+      }
+      const qs = params.toString();
+      if (qs) {
+        url += `?${qs}`;
+      }
+    }
+    const headers = {
+      ...this.jwtToken ? { Authorization: `Bearer ${this.jwtToken}` } : this.apiKey ? { "api-key": this.apiKey } : {},
+      ...options?.headers
+    };
+    if (options?.body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const idempotencyKey = findIdempotencyKey(headers)?.trim();
+    const isRetryable = method === "GET" || method === "DELETE" || idempotencyKey !== void 0 && idempotencyKey !== "";
+    const serializedBody = options?.body ? JSON.stringify(options.body) : void 0;
+    const callerSignal = options?.signal;
+    if (callerSignal?.aborted) {
+      throw new DelopayError("Request aborted", {
+        status: 0,
+        code: "ABORTED",
+        type: "abort_error"
+      });
+    }
+    const timeoutMs = options?.timeout ?? this.timeout;
+    let lastError;
+    let retryAfterOverrideMs = null;
+    const safeUrl = () => redactUrlForLogging(url);
+    const emit = (event, data) => {
+      if (!this.debug) return;
+      if (this.logger) {
+        this.logger(event, data);
+        return;
+      }
+      if (event === "request")
+        console.log(`[delopay] ${data.method} ${data.url}`);
+      else if (event === "response")
+        console.log(
+          `[delopay] ${data.status} ${data.method} ${data.path}`
+        );
+      else
+        console.log(
+          `[delopay] retry ${data.attempt}/${data.maxRetries} ${data.method} ${data.path}`
+        );
+    };
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        const base = Math.min(500 * 2 ** (attempt - 1), 5e3);
+        const jittered = Math.random() * base;
+        const delay = Math.max(retryAfterOverrideMs ?? 0, jittered);
+        retryAfterOverrideMs = null;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        emit("retry", { attempt, maxRetries: this.maxRetries, method, path });
+      }
+      const timeoutCtrl = new AbortController();
+      const timeoutId = setTimeout(() => timeoutCtrl.abort(), timeoutMs);
+      const combined = combineSignals(
+        callerSignal ? [timeoutCtrl.signal, callerSignal] : [timeoutCtrl.signal]
+      );
+      try {
+        emit("request", { method, url: safeUrl(), path });
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: serializedBody,
+          signal: combined.signal
+        });
+        const requestId = response.headers?.get("x-request-id") ?? response.headers?.get("x-trace-id") ?? void 0;
+        emit("response", { status: response.status, method, path, requestId });
+        if (!response.ok) {
+          const rawBody = await response.text().catch(() => "");
+          let parsed = {};
+          if (rawBody) {
+            try {
+              parsed = JSON.parse(rawBody);
+            } catch {
+            }
+          }
+          const err = parsed.error ?? parsed;
+          const message = err.message ?? `Request failed with status ${response.status}`;
+          const code = err.code ?? "";
+          const type = err.error_type ?? err.type ?? "";
+          const truncatedRaw = truncateRawBody(rawBody);
+          if (response.status === 401) {
+            throw new DelopayAuthenticationError(message, {
+              code,
+              type,
+              requestId,
+              rawBody: truncatedRaw
+            });
+          }
+          const error = new DelopayError(message, {
+            status: response.status,
+            code,
+            type,
+            requestId,
+            rawBody: truncatedRaw
+          });
+          const isTransientStatus = response.status >= 500 || response.status === 429;
+          if (isTransientStatus && isRetryable && attempt < this.maxRetries) {
+            if (response.status === 429) {
+              retryAfterOverrideMs = parseRetryAfter(response.headers?.get("retry-after") ?? null);
+            }
+            lastError = error;
+            continue;
+          }
+          throw error;
+        }
+        const text = await response.text();
+        return text ? JSON.parse(text) : void 0;
+      } catch (err) {
+        if (err instanceof DelopayError || err instanceof DelopayAuthenticationError) {
+          throw err;
+        }
+        if (err instanceof Error && err.name === "AbortError") {
+          if (callerSignal?.aborted) {
+            throw new DelopayError("Request aborted", {
+              status: 0,
+              code: "ABORTED",
+              type: "abort_error"
+            });
+          }
+          lastError = new DelopayError("Request timed out", {
+            status: 0,
+            code: "TIMEOUT",
+            type: "timeout_error"
+          });
+          if (isRetryable && attempt < this.maxRetries) continue;
+          throw lastError;
+        }
+        if (err instanceof TypeError) {
+          lastError = new DelopayError(`Network error: ${err.message}`, {
+            status: 0,
+            code: "NETWORK",
+            type: "network_error"
+          });
+          if (isRetryable && attempt < this.maxRetries) continue;
+          throw lastError;
+        }
+        throw err;
+      } finally {
+        clearTimeout(timeoutId);
+        combined.dispose();
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Auto-paginate a list endpoint. Yields items one by one, fetching
+   * the next page automatically when the current one is exhausted.
+   *
+   * @param listFn - A function that takes `{ limit, offset }` and returns `{ data: T[] }` or `T[]`.
+   * @param params - Additional parameters to pass to every page request.
+   * @param pageSize - Number of items per page. Defaults to `50`.
+   *
+   * @example
+   * ```typescript
+   * for await (const payment of delopay.paginate(
+   *   (p) => delopay.payments.list(p),
+   * )) {
+   *   console.log(payment.payment_id);
+   * }
+   * ```
+   */
+  async *paginate(listFn, params, pageSize = 50) {
+    let offset = 0;
+    while (true) {
+      const result = await listFn({
+        ...params ?? {},
+        limit: pageSize,
+        offset
+      });
+      const items = Array.isArray(result) ? result : result.data;
+      if (items.length === 0) break;
+      for (const item of items) {
+        yield item;
+      }
+      if (items.length < pageSize) break;
+      offset += items.length;
+    }
+  }
+};
+/** Utility for verifying incoming webhook signatures (static, no instance needed). */
+Delopay.webhooks = Webhooks;
+
+export {
+  DelopayError,
+  DelopayAuthenticationError,
+  Webhooks,
+  Analytics,
+  AnalyticsDashboard,
+  Cache,
+  Cards,
+  Configs,
+  Export,
+  FeatureMatrix,
+  Files,
+  Forex,
+  Regions,
+  Subscriptions,
+  Delopay
+};
+//# sourceMappingURL=chunk-LCF7ILAH.js.map