@delopay/sdk 0.46.0 → 0.48.0

package/dist/internal.cjs

@@ -55,6 +55,8 @@ __export(internal_exports, {
   Search: () => Search,
   Subscriptions: () => Subscriptions,
   Webhooks: () => Webhooks,
+  allOf: () => allOf,
+  anyOf: () => anyOf,
   applyBrandingVariables: () => applyBrandingVariables,
   buildBrandingExport: () => buildBrandingExport,
   buttonPadValue: () => buttonPadValue,
@@ -70,9 +72,12 @@ __export(internal_exports, {
   inputPadValue: () => inputPadValue,
   isDarkSurface: () => isDarkSurface,
   isHexColor: () => isHexColor,
+  leaf: () => leaf,
   logoDimensions: () => logoDimensions,
   parseImportedBranding: () => parseImportedBranding,
+  programToTree: () => programToTree,
   radiusValue: () => radiusValue,
+  ruleMatchToTree: () => ruleMatchToTree,
   sanitizeCustomCss: () => sanitizeCustomCss,
   shadowFor: () => shadowFor,
   surfacePadValue: () => surfacePadValue,
@@ -809,6 +814,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
@@ -2741,6 +2760,21 @@ var AvailabilityOverrides = class {
   async delete(id) {
     return this.request("DELETE", `/availability-overrides/${encodeURIComponent(id)}`);
   }
+  /**
+   * Preview the methods a customer in `country` would be shown for a shop —
+   * the connector ceiling narrowed by the smart country defaults and the
+   * merchant overrides, without an active payment.
+   * `GET /availability-overrides/preview`
+   */
+  async preview(params) {
+    return this.request("GET", "/availability-overrides/preview", {
+      query: {
+        merchant_id: params.merchant_id,
+        profile_id: params.profile_id,
+        ...params.country ? { country: params.country } : {}
+      }
+    });
+  }
 };
 
 // src/resources/subscriptions.ts
@@ -3240,6 +3274,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;
@@ -3272,9 +3316,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 = [];
@@ -3282,10 +3400,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;
   }
@@ -4384,6 +4504,17 @@ var PlatformFeeRulesManager = 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.
+   */
+  async preview(input, merchantId) {
+    return this.request("POST", "/admin/fees/rules/preview", {
+      body: input,
+      query: { merchant_id: merchantId }
+    });
+  }
 };
 
 // src/internal/client.ts
@@ -4441,6 +4572,8 @@ var DelopayInternal = class extends Delopay {
   Search,
   Subscriptions,
   Webhooks,
+  allOf,
+  anyOf,
   applyBrandingVariables,
   buildBrandingExport,
   buttonPadValue,
@@ -4456,9 +4589,12 @@ var DelopayInternal = class extends Delopay {
   inputPadValue,
   isDarkSurface,
   isHexColor,
+  leaf,
   logoDimensions,
   parseImportedBranding,
+  programToTree,
   radiusValue,
+  ruleMatchToTree,
   sanitizeCustomCss,
   shadowFor,
   surfacePadValue,