@delopay/sdk 0.158.0 → 0.162.0

package/dist/{chunk-4YLUV3YJ.js → chunk-P2KP3WRS.js}

@@ -2690,8 +2690,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}`
    */
@@ -2716,13 +2717,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}`
    */
@@ -4388,6 +4393,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) {
@@ -5308,6 +5468,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);
@@ -8197,11 +8359,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)
     });
@@ -8275,12 +8488,29 @@ var CheckoutSession = class {
    * checkout payload with `card_connector_server_confirm: true`. Stripe refuses
    * a Stripe.js confirm of such an intent.
    *
-   * Send the ConfirmationToken the Payment Element (or Express Checkout
-   * Element) produced. The router judges the card's issuing country and the
-   * buyer's IP country against the shop's sell-to restrictions before Stripe
-   * authorises, and a refusal throws a `DelopayError` with code `DE_10`. When
-   * the answer's `status` is `requires_action`, run `stripe.handleNextAction`
-   * with its `client_secret`, then call this again without a token to finalize.
+   * Send the PaymentMethod `stripe.createPaymentMethod` produced from the
+   * Payment Element (or Express Checkout Element), which needs
+   * `paymentMethodCreation: 'manual'` on the Elements instance. A
+   * ConfirmationToken is refused with `400`: Stripe will not confirm such an
+   * intent with one.
+   *
+   * The router judges the card's issuing country and the buyer's IP country
+   * against the shop's sell-to restrictions before Stripe authorises, and a
+   * refusal throws a `DelopayError` with code `DE_10`. When the answer's
+   * `status` is `requires_action`, run `stripe.handleNextAction` with its
+   * `client_secret` — safe, because the intent is `confirmation_method=manual`
+   * and that secret confirms nothing without the secret key — then call this
+   * again without a payment method to finalize.
+   *
+   * A PaymentMethod rules out what `stripe.createPaymentMethod` cannot
+   * produce: Stripe names Amazon Pay and Klarna in the Express Checkout
+   * Element, which need `stripe.createConfirmationToken` instead. Neither can
+   * be paid through this route, so a caller must not offer them on a
+   * server-confirmed intent — mount the Express Checkout Element with those
+   * methods `'never'`, as DeloPay's own checkout does. The router drops only
+   * the methods its server-side confirm cannot finish at all (BLIK and ACSS
+   * pre-authorized debits) from the card form's mount, so the rest of the
+   * selection still reaches the element and is the caller's to constrain.
    *
    * `POST /payment-link/{merchantId}/{paymentId}/stripe-confirm`
    */
@@ -8291,6 +8521,27 @@ var CheckoutSession = class {
       headers: this.bearerHeaders(options?.headers)
     });
   }
+  /**
+   * Ask whether NomuPay's COPYandPAY widget may submit a card, from the
+   * form's pre-submit hook.
+   *
+   * Only for a checkout stamped `NomupayOppwaCheckoutData.submit_grant`: the
+   * card form sits beside always-shown wallet buttons of another account, and
+   * this answer closes those buttons before it allows the card. `authorized`
+   * is `false` when the payment no longer waits for a payment method, or when
+   * this is not the attempt's live card-form checkout; when a wallet beside it
+   * is already being paid, the route answers an error instead. Submit the
+   * widget only on `true`.
+   *
+   * `POST /payment-link/{merchantId}/{paymentId}/nomupay-card-authorization`
+   */
+  async nomupayCardAuthorization(params, options) {
+    return this.client.request("POST", `${this.linkBase}/nomupay-card-authorization`, {
+      body: params,
+      ...options,
+      headers: this.bearerHeaders(options?.headers)
+    });
+  }
   /**
    * The payment's current state — status polling for redirect/popup rails.
    *
@@ -8821,6 +9072,8 @@ export {
   Regions,
   AvailabilityOverrides,
   SellToRestrictions,
+  CostRules,
+  ProcessorCosts,
   CheckoutMethods,
   Subscriptions,
   Audit,
@@ -8999,4 +9252,4 @@ export {
   decodeNativePanes,
   encodeNativePanes
 };
-//# sourceMappingURL=chunk-4YLUV3YJ.js.map
+//# sourceMappingURL=chunk-P2KP3WRS.js.map