@delopay/sdk 0.47.0 → 0.48.0

package/dist/{chunk-NNSPBDYP.js → chunk-SX46W7E4.js}

@@ -727,6 +727,20 @@ var FeeRulesManager = class {
       query: { merchant_id: merchantId, profile_id: profileId }
     });
   }
+  /**
+   * Dry-run a candidate fee-rule program against a sample transaction.
+   * Returns the matched rule name, whether it fell through, and the computed fee.
+   * Does not persist anything.
+   *
+   * @param input - Candidate program + sample transaction fields.
+   * @param merchantId - The merchant account ID.
+   */
+  async preview(input, merchantId) {
+    return this.request("POST", "/merchant-fees/rules/preview", {
+      body: input,
+      query: { merchant_id: merchantId }
+    });
+  }
 };
 
 // src/resources/mandates.ts
@@ -3173,6 +3187,16 @@ var Delopay = class {
 Delopay.webhooks = Webhooks;
 
 // src/feeProgram.ts
+function leaf(lhs, comparison, value) {
+  const tagged = typeof value === "number" ? { type: "number", value } : { type: "enum_variant", value };
+  return { kind: "leaf", lhs, comparison, value: tagged };
+}
+function allOf(...children) {
+  return { kind: "all", children };
+}
+function anyOf(...children) {
+  return { kind: "any", children };
+}
 function toFeeOutput(spec) {
   const hasPct = spec.percentage != null;
   const hasFlat = spec.flat != null;
@@ -3205,9 +3229,83 @@ function buildConditions(when = {}, raw = []) {
   if (when.amountLessThan != null) {
     out.push(numberCondition("amount", "less_than", when.amountLessThan));
   }
+  if (when.merchantVolumeEquals != null) {
+    out.push(numberCondition("merchant_volume", "equal", when.merchantVolumeEquals));
+  }
+  if (when.merchantVolumeGreaterThan != null) {
+    out.push(numberCondition("merchant_volume", "greater_than", when.merchantVolumeGreaterThan));
+  }
+  if (when.merchantVolumeLessThan != null) {
+    out.push(numberCondition("merchant_volume", "less_than", when.merchantVolumeLessThan));
+  }
   out.push(...raw);
   return out;
 }
+function leafToComparison(node) {
+  return { lhs: node.lhs, comparison: node.comparison, value: node.value, metadata: {} };
+}
+function normalizeNode(node) {
+  if (node.kind === "leaf") return node;
+  const children = node.children.map(normalizeNode);
+  const flat = [];
+  for (const c of children) {
+    if (c.kind === node.kind) flat.push(...c.children);
+    else flat.push(c);
+  }
+  if (flat.length === 1) return flat[0];
+  return { kind: node.kind, children: flat };
+}
+function toStatement(node) {
+  if (node.kind === "leaf") return { condition: [leafToComparison(node)], nested: null };
+  if (node.kind === "any") {
+    return { condition: [], nested: node.children.map(toStatement) };
+  }
+  const leaves = node.children.filter((c) => c.kind === "leaf");
+  const groups = node.children.filter((c) => c.kind !== "leaf");
+  const condition = leaves.map(leafToComparison);
+  if (groups.length === 0) return { condition, nested: null };
+  const [first, ...rest] = groups;
+  const nested = first.children.map((branch) => toStatement(normalizeNode(allOf(branch, ...rest))));
+  return { condition, nested };
+}
+function assertNoEmptyAnyOf(node) {
+  if (node.kind === "leaf") return;
+  if (node.kind === "any" && node.children.length === 0) {
+    throw new Error("feeProgram: an anyOf() group must have at least one condition");
+  }
+  node.children.forEach(assertNoEmptyAnyOf);
+}
+function encodeStatements(match) {
+  const m = normalizeNode(match);
+  if (m.kind === "any") return m.children.map(toStatement);
+  return [toStatement(m)];
+}
+function comparisonToLeaf(c) {
+  return { kind: "leaf", lhs: c.lhs, comparison: c.comparison, value: c.value };
+}
+function statementToNode(stmt) {
+  const leaves = stmt.condition.map(comparisonToLeaf);
+  if (stmt.nested && stmt.nested.length > 0) {
+    const orNode = anyOf(...stmt.nested.map(statementToNode));
+    if (leaves.length === 0) return orNode;
+    return allOf(...leaves, orNode);
+  }
+  return leaves.length === 1 ? leaves[0] : allOf(...leaves);
+}
+function ruleMatchToTree(statements) {
+  if (statements.length === 1) return normalizeNode(statementToNode(statements[0]));
+  return normalizeNode(anyOf(...statements.map(statementToNode)));
+}
+function programToTree(program) {
+  return {
+    rules: program.rules.map((r) => ({
+      name: r.name,
+      match: ruleMatchToTree(r.statements),
+      fee: r.connectorSelection.fee ?? null
+    })),
+    otherwise: program.defaultSelection.fee ?? null
+  };
+}
 var FeeProgramBuilder = class {
   constructor() {
     this.rules = [];
@@ -3215,10 +3313,12 @@ var FeeProgramBuilder = class {
   }
   /** Append a rule. Provided `when`/`rawConditions` are ANDed. */
   rule(input) {
+    if (input.match) assertNoEmptyAnyOf(input.match);
+    const statements = input.match ? encodeStatements(input.match) : [{ condition: buildConditions(input.when, input.rawConditions) }];
     this.rules.push({
       name: input.name,
       connectorSelection: { fee: toFeeOutput(input.fee) },
-      statements: [{ condition: buildConditions(input.when, input.rawConditions) }]
+      statements
     });
     return this;
   }
@@ -3887,6 +3987,11 @@ export {
   AvailabilityOverrides,
   Subscriptions,
   Delopay,
+  leaf,
+  allOf,
+  anyOf,
+  ruleMatchToTree,
+  programToTree,
   FeeProgramBuilder,
   feeProgram,
   fontStack,
@@ -3918,4 +4023,4 @@ export {
   applyBrandingVariables,
   shadowFor
 };
-//# sourceMappingURL=chunk-NNSPBDYP.js.map
+//# sourceMappingURL=chunk-SX46W7E4.js.map