@delopay/sdk 0.159.0 → 0.162.0

package/dist/index.cjs

@@ -58,6 +58,7 @@ __export(index_exports, {
   Cards: () => Cards,
   CheckoutMethods: () => CheckoutMethods,
   CheckoutSession: () => CheckoutSession,
+  CostRules: () => CostRules,
   DEFAULT_BADGES: () => DEFAULT_BADGES,
   DEFAULT_BADGES_DARK: () => DEFAULT_BADGES_DARK,
   DEFAULT_BRANDING: () => DEFAULT_BRANDING,
@@ -89,6 +90,7 @@ __export(index_exports, {
   PAYPAL_CARD_LAYOUTS: () => PAYPAL_CARD_LAYOUTS,
   PAYPAL_LABEL_STYLES: () => PAYPAL_LABEL_STYLES,
   PaypalDisputes: () => PaypalDisputes,
+  ProcessorCosts: () => ProcessorCosts,
   RTL_CHECKOUT_LOCALES: () => RTL_CHECKOUT_LOCALES,
   Regions: () => Regions,
   Risk: () => Risk,
@@ -2909,8 +2911,9 @@ var Routing = class {
     });
   }
   /**
-   * A shop's lifetime per-connector payment caps, each with how much of it is
-   * already spent.
+   * A shop's per-connector caps, each with its unit and window and how much of
+   * the current window is spent (`used`) or held by payments in flight
+   * (`reserved`).
    *
    * `GET /routing/connector-caps/{profileId}`
    */
@@ -2935,13 +2938,17 @@ var Routing = class {
     return this.request("GET", `/routing/volume-counters/${encodeURIComponent(profileId)}`);
   }
   /**
-   * Replace a shop's per-connector payment caps.
+   * Replace a shop's per-connector caps.
    *
    * Whole-set replacement, not a patch: the list sent becomes the complete set
    * of capped connectors, and an empty list clears them all — which is how
    * acquirer onboarding finishes, the new account ceasing to be a special case.
+   * Re-send every other cap with its `unit`, `window` and `currency` as read:
+   * an amount cap sent back without its `unit` is refused, because it carries a
+   * currency and would otherwise be a payment count.
    *
    * Every account named must belong to this shop; one that does not is refused.
+   * So is an amount cap without a `currency`, and a payment cap with one.
    *
    * `PUT /routing/connector-caps/{profileId}`
    */
@@ -4607,6 +4614,161 @@ var SellToRestrictions = class {
   }
 };
 
+// src/resources/costRules.ts
+var CostRules = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Every cost rule of the merchant.
+   * `GET /cost-rules`
+   *
+   * @param merchantId - The merchant account ID.
+   */
+  async list(merchantId) {
+    return this.request("GET", "/cost-rules", { query: { merchant_id: merchantId } });
+  }
+  /**
+   * Record a cost rule.
+   * `POST /cost-rules`
+   *
+   * @param params - The rule.
+   * @param merchantId - The merchant account ID.
+   */
+  async create(params, merchantId) {
+    return this.request("POST", "/cost-rules", {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Close, deactivate or rename a cost rule.
+   * `PUT /cost-rules/{rule_id}`
+   *
+   * @param ruleId - The rule ID.
+   * @param params - What to change.
+   * @param merchantId - The merchant account ID.
+   */
+  async update(ruleId, params, merchantId) {
+    return this.request("PUT", `/cost-rules/${encodeURIComponent(ruleId)}`, {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Delete a cost rule.
+   * `DELETE /cost-rules/{rule_id}`
+   *
+   * @param ruleId - The rule ID.
+   * @param merchantId - The merchant account ID.
+   */
+  async delete(ruleId, merchantId) {
+    return this.request("DELETE", `/cost-rules/${encodeURIComponent(ruleId)}`, {
+      query: { merchant_id: merchantId }
+    });
+  }
+};
+
+// src/resources/processorCosts.ts
+var ProcessorCosts = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Every processor cost schedule of the merchant.
+   * `GET /processor-costs`
+   *
+   * @param merchantId - The merchant account ID.
+   */
+  async list(merchantId) {
+    return this.request("GET", "/processor-costs", { query: { merchant_id: merchantId } });
+  }
+  /**
+   * Record a processor cost schedule.
+   * `POST /processor-costs`
+   *
+   * A `shop_id` that is well formed but not a shop of this merchant is
+   * answered `404` and nothing is recorded: a rate scoped to a shop the
+   * merchant does not own would price no attempt, leaving every line it was
+   * meant to price `unavailable` while the screen showed a configured rate.
+   *
+   * @param params - The schedule.
+   * @param merchantId - The merchant account ID.
+   */
+  async create(params, merchantId) {
+    return this.request("POST", "/processor-costs", {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Record several schedules at once, all or none — copy a price list across
+   * methods or shops.
+   * `POST /processor-costs/bulk`
+   *
+   * 1 to 200 entries. Every entry is validated before anything is stored: an
+   * invalid one is answered `422` naming its index, and nothing is stored.
+   * The answer lists the created schedules in request order.
+   *
+   * @param params - The schedules.
+   * @param merchantId - The merchant account ID.
+   */
+  async bulkCreate(params, merchantId) {
+    return this.request("POST", "/processor-costs/bulk", {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Close, deactivate or annotate a schedule. The rate is not editable.
+   * `PUT /processor-costs/{schedule_id}`
+   *
+   * @param scheduleId - The schedule ID.
+   * @param params - What to change.
+   * @param merchantId - The merchant account ID.
+   */
+  async update(scheduleId, params, merchantId) {
+    return this.request("PUT", `/processor-costs/${encodeURIComponent(scheduleId)}`, {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Close a schedule at `effective_from` and open its successor with the same
+   * scope and the same end, in one step: no transaction is priced by both
+   * rates, and none falls between them.
+   * `POST /processor-costs/{schedule_id}/replace`
+   *
+   * Answers the successor schedule. An `effective_from` outside the old
+   * schedule's window, an inactive schedule, or one a concurrent replacement
+   * already moved is answered `400` — retry against the schedule as it now
+   * stands rather than forcing the write.
+   *
+   * @param scheduleId - The schedule to replace.
+   * @param params - The new rate.
+   * @param merchantId - The merchant account ID.
+   */
+  async replace(scheduleId, params, merchantId) {
+    return this.request("POST", `/processor-costs/${encodeURIComponent(scheduleId)}/replace`, {
+      body: params,
+      query: { merchant_id: merchantId }
+    });
+  }
+  /**
+   * Delete a schedule. Restates nothing: every figure it derived is already
+   * stamped on the settlement lines it priced.
+   * `DELETE /processor-costs/{schedule_id}`
+   *
+   * @param scheduleId - The schedule ID.
+   * @param merchantId - The merchant account ID.
+   */
+  async delete(scheduleId, merchantId) {
+    return this.request("DELETE", `/processor-costs/${encodeURIComponent(scheduleId)}`, {
+      query: { merchant_id: merchantId }
+    });
+  }
+};
+
 // src/resources/checkoutMethods.ts
 var CheckoutMethods = class {
   constructor(request) {
@@ -5527,6 +5689,8 @@ var Delopay = class {
     this.regions = new Regions(request);
     this.availabilityOverrides = new AvailabilityOverrides(request);
     this.sellToRestrictions = new SellToRestrictions(request);
+    this.costRules = new CostRules(request);
+    this.processorCosts = new ProcessorCosts(request);
     this.checkoutMethods = new CheckoutMethods(request);
     this.analytics = new Analytics(request);
     this.analyticsDashboard = new AnalyticsDashboard(request);
@@ -8416,11 +8580,62 @@ var CheckoutSession = class {
    *
    * `GET /payment-link/{merchantId}/{paymentId}/epayouts/methods`
    *
+   * Pass `{ paypalSdk: true }` from a checkout drawing an experimental PayPal
+   * SDK pane to also receive e-Payouts' PayPal client id
+   * (`paypal_client_id`, `paypal_currency`); it is present only when `ppal`
+   * is among the methods.
+   *
    * @param country - Lowercase ISO 3166-1 alpha-2 country code.
    */
   async epayoutsMethods(country, options) {
+    const { paypalSdk, merchantConnectorId, ...extras } = options ?? {};
     return this.client.request("GET", `${this.linkBase}/epayouts/methods`, {
-      query: { cc: country },
+      query: paypalSdk ? {
+        cc: country,
+        paypal_sdk: "true",
+        ...merchantConnectorId ? { merchant_connector_id: merchantConnectorId } : {}
+      } : { cc: country },
+      ...extras,
+      headers: this.bearerHeaders(extras.headers)
+    });
+  }
+  /**
+   * The PayPal order for the payment's e-Payouts access code, from the PayPal
+   * SDK's `createOrder` on an experimental PayPal SDK pane — after the payment
+   * was confirmed through that pane, which mints the code.
+   *
+   * The router reads the order off e-Payouts' own PayPal page for the code, so
+   * `amount` and `currency` are what e-Payouts charges for it. Repeated calls
+   * answer the same order, so a cancelled PayPal popup is retried with the same
+   * code. When `captured` is `true` a capture was already reported: create no
+   * order and wait for the payment's status instead.
+   *
+   * `POST /payment-link/{merchantId}/{paymentId}/epayouts/paypal-order`
+   */
+  async epayoutsPaypalOrder(options) {
+    return this.client.request("POST", `${this.linkBase}/epayouts/paypal-order`, {
+      ...options,
+      headers: this.bearerHeaders(options?.headers)
+    });
+  }
+  /**
+   * Report a PayPal order's progress from `onApprove` on an experimental PayPal
+   * SDK pane: the approval, before asking PayPal to capture — and capture only
+   * once the router has it — then the capture PayPal answered, or a decline.
+   * When the approval's answer is lost, do not capture: report `NOT_CAPTURED`
+   * instead, which releases an approval the router may have recorded.
+   *
+   * The router records each on the payment and relays a capture that took money
+   * to e-Payouts the way e-Payouts' own PayPal page does. It does not mark the
+   * payment paid: that happens only on e-Payouts' notification, so poll the
+   * payment's status afterwards. A repeated report is answered, not recorded
+   * twice.
+   *
+   * `POST /payment-link/{merchantId}/{paymentId}/epayouts/paypal-capture`
+   */
+  async epayoutsPaypalCapture(params, options) {
+    return this.client.request("POST", `${this.linkBase}/epayouts/paypal-capture`, {
+      body: params,
       ...options,
       headers: this.bearerHeaders(options?.headers)
     });
@@ -9099,6 +9314,7 @@ var encodeNativePanes = encodePanes;
   Cards,
   CheckoutMethods,
   CheckoutSession,
+  CostRules,
   DEFAULT_BADGES,
   DEFAULT_BADGES_DARK,
   DEFAULT_BRANDING,
@@ -9130,6 +9346,7 @@ var encodeNativePanes = encodePanes;
   PAYPAL_CARD_LAYOUTS,
   PAYPAL_LABEL_STYLES,
   PaypalDisputes,
+  ProcessorCosts,
   RTL_CHECKOUT_LOCALES,
   Regions,
   Risk,