@delopay/sdk 0.162.1 → 0.164.0

package/dist/{chunk-P2KP3WRS.js → chunk-GCJDY4KX.js}

@@ -1763,6 +1763,16 @@ var Payments = class {
    * Not the hosted-shop settlement API under `settlement.*`, which is host →
    * shop owner and manual; this is acquirer → merchant bank, per payment.
    *
+   * Each attempt also carries what the rail itself took for it —
+   * `processor_cost_amount` with its own `processor_cost_currency` and
+   * `processor_cost_exponent`, the `processor_cost_source` that says how the
+   * figure was obtained, the `processor_cost_basis` behind an estimate, and
+   * the `connector_method_code` it was priced under. Recorded for **every**
+   * merchant, not only those that host shops. Never present an `estimated`
+   * cost as an observation, and read an absent `processor_cost_source` as
+   * "nothing was ever written", which is not the `unavailable` the rail
+   * answers with.
+   *
    * `GET /payments/{paymentId}/settlement`
    *
    * @param paymentId - The payment intent ID.
@@ -1781,6 +1791,9 @@ var Payments = class {
    *   if (attempt.status === 'paid_out') {
    *     console.log(attempt.paid_out_at, attempt.payout_reference);
    *   }
+   *   if (attempt.processor_cost_source === 'estimated') {
+   *     // Label it an estimate — it was derived from a cost schedule.
+   *   }
    * }
    * ```
    */
@@ -4448,6 +4461,142 @@ var CostRules = class {
   }
 };
 
+// src/resources/externalRecords.ts
+var ExternalRecords = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Record one out-of-band transition.
+   * `POST /external-records`
+   *
+   * Which kinds a deployment answers for depends on the payment's connector
+   * and on which arms are live: an arm that is not served answers `501`, which
+   * is a statement about this rail rather than about the request.
+   *
+   * @param params - What happened, and why it is being recorded.
+   */
+  async create(params) {
+    return this.request("POST", "/external-records", { body: params });
+  }
+};
+
+// src/resources/products.ts
+var Products = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** The shop scope every route here takes, as the backend expects it. */
+  scoped(profileId, options) {
+    return { ...options, headers: { "X-Profile-Id": profileId, ...options?.headers } };
+  }
+  /**
+   * Create a product together with its prices.
+   * `POST /products`
+   *
+   * @param params - The product, with at least one price.
+   * @param profileId - The shop the product belongs to.
+   */
+  async create(params, profileId, options) {
+    return this.request("POST", "/products", {
+      body: params,
+      ...this.scoped(profileId, options)
+    });
+  }
+  /**
+   * One page of the shop's catalogue.
+   * `GET /products/list`
+   *
+   * Archived products are returned too unless `status` narrows them away —
+   * they are what past charges refer to.
+   */
+  async list(params, profileId, options) {
+    return this.request("GET", "/products/list", {
+      query: params === void 0 ? void 0 : { ...params },
+      ...this.scoped(profileId, options)
+    });
+  }
+  /**
+   * Retrieve one product with its prices.
+   * `GET /products/{product_id}`
+   */
+  async retrieve(productId, profileId, options) {
+    return this.request("GET", `/products/${encodeURIComponent(productId)}`, {
+      ...this.scoped(profileId, options)
+    });
+  }
+  /**
+   * Change a product's name, description or metadata.
+   * `POST /products/{product_id}`
+   *
+   * Its kind and its prices are not editable here — see the class note.
+   */
+  async update(productId, params, profileId, options) {
+    return this.request("POST", `/products/${encodeURIComponent(productId)}`, {
+      body: params,
+      ...this.scoped(profileId, options)
+    });
+  }
+  /**
+   * Take a product off sale.
+   * `POST /products/{product_id}/archive`
+   *
+   * It stays readable and keeps its prices: a payment made against it has to
+   * remain explicable after it is withdrawn.
+   */
+  async archive(productId, profileId, options) {
+    return this.request("POST", `/products/${encodeURIComponent(productId)}/archive`, {
+      ...this.scoped(profileId, options)
+    });
+  }
+  /**
+   * Put an archived product back on sale.
+   * `POST /products/{product_id}/restore`
+   */
+  async restore(productId, profileId, options) {
+    return this.request("POST", `/products/${encodeURIComponent(productId)}/restore`, {
+      ...this.scoped(profileId, options)
+    });
+  }
+  /**
+   * Add a price to an existing product.
+   * `POST /products/{product_id}/prices`
+   *
+   * This is how a price changes: the new figure is added and the old price is
+   * archived, so both remain readable.
+   */
+  async addPrice(productId, params, profileId, options) {
+    return this.request("POST", `/products/${encodeURIComponent(productId)}/prices`, {
+      body: params,
+      ...this.scoped(profileId, options)
+    });
+  }
+  /**
+   * Change a price's label, its default flag or its metadata.
+   * `POST /products/{product_id}/prices/{price_id}`
+   *
+   * Not its amount, its currency or its interval: see the class note.
+   */
+  async updatePrice(productId, priceId, params, profileId, options) {
+    return this.request(
+      "POST",
+      `/products/${encodeURIComponent(productId)}/prices/${encodeURIComponent(priceId)}`,
+      { body: params, ...this.scoped(profileId, options) }
+    );
+  }
+  /**
+   * Take one price off sale, leaving the product on it.
+   * `POST /products/{product_id}/prices/{price_id}/archive`
+   */
+  async archivePrice(productId, priceId, profileId, options) {
+    return this.request(
+      "POST",
+      `/products/${encodeURIComponent(productId)}/prices/${encodeURIComponent(priceId)}/archive`,
+      { ...this.scoped(profileId, options) }
+    );
+  }
+};
+
 // src/resources/processorCosts.ts
 var ProcessorCosts = class {
   constructor(request) {
@@ -4880,6 +5029,65 @@ var Settlement = class {
       ...options
     });
   }
+  /**
+   * What a period's payments cost at the rails, grouped by shop, connector
+   * and payment method. Answers for **every** merchant, including one that
+   * hosts nobody — it reads the per-attempt settlement record rather than the
+   * settlement lines, which exist only where hosting fees are configured.
+   *
+   * A sibling of {@link Settlement.cost} rather than a widening of it. That
+   * endpoint is a profit statement whose revenue term is hosting income, and
+   * a merchant who hosts nobody has none. This publishes cost and never
+   * margin.
+   *
+   * Send `year` and `month` together to report one UTC calendar month, or
+   * neither for the running month so far.
+   *
+   * **The response carries no period total, and a caller must not compute
+   * one here.** Every figure keeps the unit the rail reported it in, and the
+   * unit is part of each bucket's key, so adding two buckets is not addition.
+   * Convert caller-side if you need one number, and say which rates you used.
+   * The counts are totalled, because a count has no unit.
+   *
+   * Two distinctions not to flatten when rendering a bucket:
+   * `cost_amount` covers `reported_count + estimated_count` attempts out of
+   * `attempt_count` and is a lower bound whenever those disagree; and
+   * `unavailable_count` (the rail says it has no figure) means something
+   * different from `unwritten_count` (a gap in our own recording).
+   *
+   * **Merchant scope.** A token scoped to a single shop, a role narrowed to
+   * specific connector accounts, or a role without the settlement-read
+   * permission group is refused `403`: what a rail charged is the merchant's
+   * own cost base, and here it is the whole response, so there is nothing
+   * coherent to redact down to. Gate the surface on the caller's scope rather
+   * than calling it and handling the failure.
+   *
+   * `GET /settlement/processor-cost`
+   *
+   * @example
+   * ```typescript
+   * const period = await delopay.settlement.processorCost({
+   *   test_mode: false,
+   *   year: 2026,
+   *   month: 7,
+   * });
+   * for (const bucket of period.buckets) {
+   *   // Each bucket is its own unit — render per bucket, never a sum.
+   *   console.log(bucket.connector, bucket.cost_amount, bucket.cost_currency);
+   * }
+   * ```
+   */
+  async processorCost(params, options) {
+    return this.request("GET", "/settlement/processor-cost", {
+      query: {
+        profile_id: params?.profile_id,
+        test_mode: params?.test_mode,
+        year: params?.year,
+        month: params?.month
+      },
+      ...options
+    });
+  }
   /**
    * List generated settlement statements, newest first.
    *
@@ -5469,6 +5677,8 @@ var Delopay = class {
     this.availabilityOverrides = new AvailabilityOverrides(request);
     this.sellToRestrictions = new SellToRestrictions(request);
     this.costRules = new CostRules(request);
+    this.externalRecords = new ExternalRecords(request);
+    this.products = new Products(request);
     this.processorCosts = new ProcessorCosts(request);
     this.checkoutMethods = new CheckoutMethods(request);
     this.analytics = new Analytics(request);
@@ -9073,6 +9283,8 @@ export {
   AvailabilityOverrides,
   SellToRestrictions,
   CostRules,
+  ExternalRecords,
+  Products,
   ProcessorCosts,
   CheckoutMethods,
   Subscriptions,
@@ -9252,4 +9464,4 @@ export {
   decodeNativePanes,
   encodeNativePanes
 };
-//# sourceMappingURL=chunk-P2KP3WRS.js.map
+//# sourceMappingURL=chunk-GCJDY4KX.js.map