@fire-spark/payments 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,98 @@
-import { OrderTotals, PaymentMethod, PaymentProvider } from "@fire-spark/types";
+import { MixedPaymentsEffect, OrderLine, OrderTotals, PaymentCollectAt, PaymentCollectAt as PaymentCollectAt$1, PaymentErrorCode as PaymentErrorCode$1, PaymentIntent, PaymentMethod, PaymentProvider, PaymentScope, PaymentStatus, PaymentTender, TenderAllocation, TenderAllocationInput, TenderAmount, TenderDetails } from "@fire-spark/types";
+//#region src/allocation.d.ts
+/** `metadata.fee_based_on` values that are a tip (always primary, D18). */
+declare const TIP_FEE_BASED_ON: readonly string[];
+/** `metadata.fee_based_on` values that are delivery (always primary, D18). */
+declare const DELIVERY_FEE_BASED_ON: readonly string[];
+type AllocateTenderInput = {
+  id: string;
+  sequence: number;
+  method: PaymentMethod;
+  allocation: TenderAllocationInput | null;
+  /** Value a REDEMPTION tender covers (`details.points_value`). */
+  redemption_amount?: number;
+};
+type AllocateTendersInput = {
+  lines: readonly OrderLine[];
+  totals: OrderTotals;
+  tenders: readonly AllocateTenderInput[];
+};
+type AllocatedTender = {
+  id: string;
+  sequence: number;
+  method: PaymentMethod;
+  allocation: TenderAllocation | null;
+  amount: TenderAmount;
+};
+type AllocationError = {
+  code: PaymentErrorCode$1;
+  message: string;
+  tender_id?: string;
+  line_uid?: string;
+};
+type AllocateTendersResult = {
+  ok: true;
+  tenders: AllocatedTender[];
+  primary_tender_id: string | null;
+} | {
+  ok: false;
+  error: AllocationError;
+};
+/** Tip fee line (`metadata.fee_based_on = TIPS`). */
+declare const isTipFee: (line: OrderLine) => boolean;
+/** Delivery fee line (distance or coverage zone based). */
+declare const isDeliveryFee: (line: OrderLine) => boolean;
+/**
+ * Splits `amount` (minor units) by `units / quantity` per part. Each part
+ * gets the floor of its exact share; the residual goes one minor unit at a
+ * time to the largest discarded fraction, ties to the lowest `sequence`.
+ */
+declare const prorateMinor: (amount: number, quantity: number, parts: readonly {
+  units: number;
+  sequence: number;
+}[]) => number[];
+/**
+ * Server-side money of every tender (§3.2): whole lines as stored, parts
+ * prorated per component with the residual minor unit to the largest
+ * discarded fraction, fees to their tender, tip / delivery and order-level
+ * adjustments to the primary, then REDEMPTION deducted from the primary
+ * first and by `sequence`, never below a tender's tip + delivery (D18).
+ */
+declare const allocateTenders: (input: AllocateTendersInput) => AllocateTendersResult;
+/**
+ * Items of one real tender (D8): whole `PRODUCT` parent lines plus each
+ * part (1 each). Children, fees and REDEMPTION never count; units do not
+ * add up. `null` allocation = every product parent line.
+ */
+declare const countTenderItems: (allocation: Pick<TenderAllocationInput, "lines"> | null, lines: readonly OrderLine[]) => number;
+type RulesTender = {
+  id: string;
+  method: PaymentMethod;
+  amount: {
+    total: number;
+    currency: string;
+  };
+  allocation: Pick<TenderAllocationInput, "lines"> | null;
+};
+type ValidateTendersResult = {
+  ok: true;
+  is_mixed: boolean;
+} | {
+  ok: false;
+  error: AllocationError & {
+    reason?: string;
+  };
+};
+/**
+ * Mixed payments rules over real tenders only (D17): a REDEMPTION never
+ * makes an order mixed, counts as a method, an item or an amount.
+ */
+declare const validateTendersAgainstRules: (input: {
+  tenders: readonly RulesTender[];
+  lines: readonly OrderLine[];
+  effect: MixedPaymentsEffect | null;
+}) => ValidateTendersResult;
+//#endregion
 //#region src/errors.d.ts
 type PaymentErrorReason = "timeout" | "network" | "declined" | "provider" | "ambiguous" | "user";
 type ErrorDefaults = {
@@ -106,8 +200,8 @@ declare const isPaymentError: (value: unknown) => value is PaymentError;
 declare const formatPaymentError: (error: StandardPaymentError, providerName?: string) => string;
 //#endregion
 //#region src/types.d.ts
-type PaymentCollectAt = "DEVICE" | "KIOSK" | "COUNTER" | "DOOR" | "OTHER";
-type PaymentIntentStatus = "IDLE" | "PENDING" | "PAID" | "FAILED" | "CANCELLED" | "REFUNDED";
+/** Status of one tender attempt (same values as order `payment_status`). */
+type PaymentIntentStatus = PaymentStatus;
 type PaymentEnvironment = "sandbox" | "production";
 /** Amount of one intent, already in the charge currency. */
 type PaymentAmount = {
@@ -213,7 +307,7 @@ type PaymentContext = {
   customer: PaymentCustomer;
   amount: PaymentAmount;
   taxes: TaxBreakdown[];
-  collectAt: PaymentCollectAt;
+  collectAt: PaymentCollectAt$1;
   attemptReference: string;
   attempt: number;
   environment: PaymentEnvironment;
@@ -293,6 +387,8 @@ type PaymentResult = {
   amount: number;
   metadata: PaymentMetadata;
   error?: StandardPaymentError;
+  /** Non-sensitive tender data recorded with the attempt (§3.1). */
+  details?: TenderDetails | null;
 };
 type PaymentReversal = "cancel" | "refund" | "manual";
 type PaymentOperation = (ctx: PaymentContext, result: PaymentResult) => Promise<PaymentResult>;
@@ -307,8 +403,15 @@ type PaymentAdapter = {
   refund?: PaymentOperation;
   reversalFor?(result: PaymentResult, now: Date): PaymentReversal;
   terminal?: TerminalOperations;
+  capabilities?: PaymentAdapterCapabilities;
   errors: PaymentErrorDictionary;
 };
+type PaymentAdapterCapabilities = {
+  /** Authorizes first and captures with `confirm` after inject (§6.1). */
+  deferredCapture?: boolean;
+  /** Collected by a person; the tender stays `IDLE` on the device. */
+  inPerson?: boolean;
+};
 //#endregion
 //#region src/amount.d.ts
 /** ISO 4217 minor units; anything not listed uses 2. */
@@ -382,6 +485,134 @@ declare const taxBreakdown: (lines: TaxLine[], options?: {
   decimals?: number;
 }) => TaxBreakdown[];
 //#endregion
+//#region src/tenders.d.ts
+declare const REDEMPTION_METHOD = "REDEMPTION";
+/** Methods that charge money (everything but `REDEMPTION`, D17). */
+declare const isRealPaymentMethod: (method: string) => boolean;
+declare const ACTIVE_INTENT_STATUSES: readonly ["DRAFT", "LOCKED"];
+/** `collect_at` charged by the SDK on the device (`digital` scope). */
+declare const DIGITAL_COLLECT_AT: readonly string[];
+/** Tender statuses that are final for one tender. */
+declare const TERMINAL_TENDER_STATUSES: readonly PaymentStatus[];
+/** Allowed status changes of one tender; late notices never downgrade. */
+declare const NEXT_STATUSES: Record<PaymentStatus, readonly PaymentStatus[]>;
+/** `error_message` of a tender failed by a partial approval (D31). */
+declare const PARTIAL_APPROVAL_ERROR = "PARTIAL_APPROVAL";
+type IntentStatusLike = {
+  status: string;
+};
+type TenderLike = {
+  id: string;
+  method: string;
+  status: PaymentStatus;
+  collect_at: string;
+  amount: {
+    total: number;
+  };
+  replaces_tender_id?: string;
+  metadata?: Record<string, unknown>;
+};
+type IntentLike<T extends TenderLike = TenderLike> = {
+  status: string;
+  totals: {
+    currency: string;
+    total: number;
+  };
+  tenders: readonly T[];
+};
+/** The one `DRAFT` / `LOCKED` intent, by status (never by position). */
+declare const activeIntent: <T extends IntentStatusLike>(intents: readonly T[] | null | undefined) => T | null;
+/** The intent that pays the order: the active one, else the completed one. */
+declare const currentIntent: <T extends IntentStatusLike>(intents: readonly T[] | null | undefined) => T | null;
+/** Tenders not replaced by a retry or a method change (D12, D25). */
+declare const liveTenders: <T extends TenderLike>(intent: {
+  tenders: readonly T[];
+} | null | undefined) => T[];
+declare const realTenders: <T extends {
+  method: string;
+}>(tenders: readonly T[]) => T[];
+/** Live real tenders of the current intent (facts for workflow edges). */
+declare const liveRealTenders: <T extends TenderLike>(intents: readonly IntentLike<T>[] | null | undefined) => T[];
+/** 2+ real tenders; `REDEMPTION` never makes an order mixed (D17). */
+declare const isMixedTenders: (tenders: readonly {
+  method: string;
+}[]) => boolean;
+/** First real tender by `sequence`; null when every tender is REDEMPTION. */
+declare const primaryTenderOf: <T extends {
+  method: string;
+  sequence: number;
+}>(tenders: readonly T[]) => T | null;
+/** The primary tender of an intent (by `primary_tender_id`). */
+declare const primaryTender: <T extends TenderLike>(intent: {
+  primary_tender_id: string | null;
+  tenders: readonly T[];
+} | null | undefined) => T | null;
+/** A REDEMPTION tender whose points are held for the order (L2 / D30). */
+declare const isRedemptionReserved: (tender: TenderLike) => boolean;
+/** Paid, or a reserved REDEMPTION (confirmed later, §3.3). */
+declare const isTenderSettled: (tender: TenderLike) => boolean;
+/** Σ `amount.total` of live, not failed/cancelled tenders. */
+declare const tendersCoverage: (tenders: readonly TenderLike[]) => number;
+/** Live tenders that are not failed/cancelled cover the order total. */
+declare const isIntentCovered: (intent: IntentLike | null | undefined, orderTotal?: number) => boolean;
+/**
+ * Order `payment_status` from the live tenders of the current intent
+ * (D32). Reserved REDEMPTION tenders count as settled, so a redemption-only
+ * intent is `PAID` once its points are held (D30).
+ */
+declare const derivePaymentStatus: (intent: IntentLike | null | undefined) => PaymentStatus;
+/** Live tenders a `PAYING` node waits for (§7.3); no scope = all. */
+declare const tendersInScope: <T extends TenderLike>(intent: {
+  tenders: readonly T[];
+} | null | undefined, scope?: PaymentScope | null) => T[];
+/**
+ * Every live tender in the node scope is settled. An empty scope is paid
+ * on entry; a scope with only REDEMPTION tenders is paid once they are
+ * reserved (D30).
+ */
+declare const isScopePaid: (intent: IntentLike | null | undefined, scope?: PaymentScope | null) => boolean;
+/** Intent status after its tenders change (`LOCKED` → `COMPLETED`). */
+declare const nextIntentStatus: (intent: {
+  status: PaymentIntent["status"];
+}, paymentStatus: PaymentStatus) => PaymentIntent["status"];
+type PaymentTenderUpdate = {
+  tender_id: string;
+  attempt_reference: string;
+  status: PaymentStatus;
+  details?: TenderDetails | null;
+  /** Amount the provider approved; less than the tender ⇒ FAILED (D31). */
+  approved_amount?: number;
+  provider_reference?: string;
+  error_message?: string;
+  metadata?: Record<string, unknown>;
+  /** ISO timestamp of the update (defaults to now). */
+  at?: string;
+};
+type MergePaymentTenderOutcome =
+/** The tender changed. */
+"APPLIED" |
+/** Same report again (idempotent by `attempt_reference`). */
+"UNCHANGED" |
+/** Not an allowed transition, or a stale attempt; nothing changed. */
+"IGNORED" |
+/** `PAID` after `CANCELLED`: money may be held; flagged for review. */
+"NEEDS_REVIEW" | "NOT_FOUND";
+type MergePaymentTenderResult<I> = {
+  outcome: MergePaymentTenderOutcome;
+  intent: I;
+  tender: PaymentTender | null;
+  /** The provider approved less than the tender (void it, D31). */
+  partialApproval: boolean;
+};
+/**
+ * Applies one tender result to its intent. Idempotent by the tender
+ * `attempt_reference`; a new reference is accepted only as a retry of an
+ * `IDLE` / `FAILED` tender (D25). A partial approval becomes `FAILED`
+ * (D31). A late `PAID` after `CANCELLED` keeps the tender cancelled and is
+ * flagged `NEEDS_REVIEW`.
+ */
+declare const mergePaymentTender: <I extends PaymentIntent>(intent: I, update: PaymentTenderUpdate) => MergePaymentTenderResult<I>;
+//#endregion
 //#region src/terminal.d.ts
 /**
  * Serializes everything that touches one terminal (charge, query, batch close)
@@ -394,4 +625,4 @@ declare const scopedPaymentStorage: (storage: PaymentStorage, paymentId: string)
 /** For tests and web previews; apps provide AsyncStorage or localStorage. */
 declare const memoryPaymentStorage: () => PaymentStorage;
 //#endregion
-export { CURRENCY_DECIMALS, ChargeConversion, DEFAULT_PAYMENT_POLICY, type DeviceField, PAYMENT_ERROR_CODES, PAYMENT_ERROR_DEFAULTS, type PaymentAction, type PaymentAdapter, type PaymentAmount, type PaymentCardType, type PaymentCollectAt, type PaymentContext, type PaymentCustomer, type PaymentEntryMode, type PaymentEnvironment, PaymentError, PaymentErrorCode, PaymentErrorDictionary, PaymentErrorEntry, PaymentErrorReason, type PaymentIntentStatus, type PaymentMetadata, type PaymentMetadataPayment, type PaymentOperation, type PaymentPolicy, type PaymentResult, type PaymentReversal, type PaymentServer, type PaymentStorage, type PaymentUI, RawPaymentError, StandardPaymentError, type TaxBreakdown, TaxLine, type TerminalContext, type TerminalOperation, type TerminalOperations, type TerminalResult, amountTolerance, batchCloseDay, createAttemptReference, createPaymentError, currencyDecimals, defaultReversalFor, definePaymentErrors, formatPaymentError, isBatchCloseDue, isPaymentError, isTerminalLocked, memoryPaymentStorage, missingDeviceFields, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, scopedPaymentStorage, taxBreakdown, toChargeAmount, toPaymentAmount, toPaymentError, withTerminalLock };
+export { ACTIVE_INTENT_STATUSES, AllocateTenderInput, AllocateTendersInput, AllocateTendersResult, AllocatedTender, AllocationError, CURRENCY_DECIMALS, ChargeConversion, DEFAULT_PAYMENT_POLICY, DELIVERY_FEE_BASED_ON, DIGITAL_COLLECT_AT, type DeviceField, MergePaymentTenderOutcome, MergePaymentTenderResult, NEXT_STATUSES, PARTIAL_APPROVAL_ERROR, PAYMENT_ERROR_CODES, PAYMENT_ERROR_DEFAULTS, type PaymentAction, type PaymentAdapter, type PaymentAdapterCapabilities, type PaymentAmount, type PaymentCardType, type PaymentCollectAt, type PaymentContext, type PaymentCustomer, type PaymentEntryMode, type PaymentEnvironment, PaymentError, PaymentErrorCode, PaymentErrorDictionary, PaymentErrorEntry, PaymentErrorReason, type PaymentIntentStatus, type PaymentMetadata, type PaymentMetadataPayment, type PaymentOperation, type PaymentPolicy, type PaymentResult, type PaymentReversal, type PaymentServer, type PaymentStorage, PaymentTenderUpdate, type PaymentUI, REDEMPTION_METHOD, RawPaymentError, RulesTender, StandardPaymentError, TERMINAL_TENDER_STATUSES, TIP_FEE_BASED_ON, type TaxBreakdown, TaxLine, type TerminalContext, type TerminalOperation, type TerminalOperations, type TerminalResult, ValidateTendersResult, activeIntent, allocateTenders, amountTolerance, batchCloseDay, countTenderItems, createAttemptReference, createPaymentError, currencyDecimals, currentIntent, defaultReversalFor, definePaymentErrors, derivePaymentStatus, formatPaymentError, isBatchCloseDue, isDeliveryFee, isIntentCovered, isMixedTenders, isPaymentError, isRealPaymentMethod, isRedemptionReserved, isScopePaid, isTenderSettled, isTerminalLocked, isTipFee, liveRealTenders, liveTenders, memoryPaymentStorage, mergePaymentTender, missingDeviceFields, nextIntentStatus, primaryTender, primaryTenderOf, prorateMinor, realTenders, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, scopedPaymentStorage, taxBreakdown, tendersCoverage, tendersInScope, toChargeAmount, toPaymentAmount, toPaymentError, validateTendersAgainstRules, withTerminalLock };

package/dist/index.js

@@ -54,6 +54,890 @@ const amountTolerance = (currency) => {
 	return 10 ** -currencyDecimals(currency) / 2;
 };
 //#endregion
+//#region src/tenders.ts
+const REDEMPTION_METHOD = "REDEMPTION";
+/** Methods that charge money (everything but `REDEMPTION`, D17). */
+const isRealPaymentMethod = (method) => {
+	return method !== REDEMPTION_METHOD;
+};
+const ACTIVE_INTENT_STATUSES = ["DRAFT", "LOCKED"];
+/** `collect_at` charged by the SDK on the device (`digital` scope). */
+const DIGITAL_COLLECT_AT = ["DEVICE"];
+/** Tender statuses that are final for one tender. */
+const TERMINAL_TENDER_STATUSES = ["CANCELLED", "REFUNDED"];
+/** Allowed status changes of one tender; late notices never downgrade. */
+const NEXT_STATUSES = {
+	IDLE: [
+		"IDLE",
+		"PENDING",
+		"PAID",
+		"FAILED",
+		"CANCELLED"
+	],
+	PENDING: [
+		"PENDING",
+		"PAID",
+		"FAILED",
+		"CANCELLED"
+	],
+	FAILED: [
+		"FAILED",
+		"PENDING",
+		"PAID",
+		"CANCELLED"
+	],
+	PAID: [
+		"PAID",
+		"CANCELLED",
+		"REFUNDED"
+	],
+	CANCELLED: ["CANCELLED"],
+	REFUNDED: ["REFUNDED"]
+};
+/** `error_message` of a tender failed by a partial approval (D31). */
+const PARTIAL_APPROVAL_ERROR = "PARTIAL_APPROVAL";
+const isActiveStatus = (status) => {
+	return ACTIVE_INTENT_STATUSES.includes(status);
+};
+/** The one `DRAFT` / `LOCKED` intent, by status (never by position). */
+const activeIntent = (intents) => {
+	return intents?.find((intent) => isActiveStatus(intent.status)) ?? null;
+};
+/** The intent that pays the order: the active one, else the completed one. */
+const currentIntent = (intents) => {
+	const active = activeIntent(intents);
+	if (active) return active;
+	return intents?.find((intent) => intent.status === "COMPLETED") ?? null;
+};
+/** Tenders not replaced by a retry or a method change (D12, D25). */
+const liveTenders = (intent) => {
+	if (!intent) return [];
+	const replaced = /* @__PURE__ */ new Set();
+	for (const tender of intent.tenders) if (tender.replaces_tender_id) replaced.add(tender.replaces_tender_id);
+	return intent.tenders.filter((tender) => !replaced.has(tender.id));
+};
+const realTenders = (tenders) => {
+	return tenders.filter((tender) => isRealPaymentMethod(tender.method));
+};
+/** Live real tenders of the current intent (facts for workflow edges). */
+const liveRealTenders = (intents) => {
+	return realTenders(liveTenders(currentIntent(intents)));
+};
+/** 2+ real tenders; `REDEMPTION` never makes an order mixed (D17). */
+const isMixedTenders = (tenders) => {
+	return realTenders(tenders).length >= 2;
+};
+/** First real tender by `sequence`; null when every tender is REDEMPTION. */
+const primaryTenderOf = (tenders) => {
+	return realTenders(tenders).toSorted((a, b) => a.sequence - b.sequence)[0] ?? null;
+};
+/** The primary tender of an intent (by `primary_tender_id`). */
+const primaryTender = (intent) => {
+	if (!intent?.primary_tender_id) return null;
+	const id = intent.primary_tender_id;
+	return intent.tenders.find((tender) => tender.id === id) ?? null;
+};
+/** A REDEMPTION tender whose points are held for the order (L2 / D30). */
+const isRedemptionReserved = (tender) => {
+	if (isRealPaymentMethod(tender.method)) return false;
+	return typeof tender.metadata?.reserved_at === "string";
+};
+/** Paid, or a reserved REDEMPTION (confirmed later, §3.3). */
+const isTenderSettled = (tender) => {
+	if (tender.status === "PAID") return true;
+	return tender.status === "PENDING" && isRedemptionReserved(tender);
+};
+const coveringTenders = (tenders) => {
+	return tenders.filter((tender) => {
+		return tender.status !== "FAILED" && tender.status !== "CANCELLED";
+	});
+};
+/** Σ `amount.total` of live, not failed/cancelled tenders. */
+const tendersCoverage = (tenders) => {
+	return coveringTenders(tenders).reduce((sum, tender) => {
+		return sum + tender.amount.total;
+	}, 0);
+};
+/** Live tenders that are not failed/cancelled cover the order total. */
+const isIntentCovered = (intent, orderTotal) => {
+	if (!intent) return false;
+	const total = orderTotal ?? intent.totals.total;
+	return tendersCoverage(liveTenders(intent)) + amountTolerance(intent.totals.currency) >= total;
+};
+/**
+* Order `payment_status` from the live tenders of the current intent
+* (D32). Reserved REDEMPTION tenders count as settled, so a redemption-only
+* intent is `PAID` once its points are held (D30).
+*/
+const derivePaymentStatus = (intent) => {
+	const tenders = liveTenders(intent);
+	if (tenders.length === 0) return "IDLE";
+	if (tenders.some((tender) => tender.status === "FAILED")) return "FAILED";
+	const statuses = tenders.map((tender) => tender.status);
+	if (statuses.every((status) => status === "CANCELLED")) return "CANCELLED";
+	const closed = (status) => {
+		return status === "REFUNDED" || status === "CANCELLED";
+	};
+	if (statuses.every(closed)) return "REFUNDED";
+	if (tenders.every((tender) => {
+		return tender.status === "REFUNDED" || isTenderSettled(tender);
+	})) return "PAID";
+	if (statuses.every((status) => status === "IDLE")) return "IDLE";
+	return "PENDING";
+};
+/** Live tenders a `PAYING` node waits for (§7.3); no scope = all. */
+const tendersInScope = (intent, scope) => {
+	const tenders = liveTenders(intent);
+	if (!scope) return tenders;
+	return tenders.filter((tender) => {
+		if (!isRealPaymentMethod(tender.method)) return scope === "digital";
+		const digital = DIGITAL_COLLECT_AT.includes(tender.collect_at);
+		return scope === "digital" ? digital : !digital;
+	});
+};
+/**
+* Every live tender in the node scope is settled. An empty scope is paid
+* on entry; a scope with only REDEMPTION tenders is paid once they are
+* reserved (D30).
+*/
+const isScopePaid = (intent, scope) => {
+	if (!intent) return false;
+	return tendersInScope(intent, scope).every(isTenderSettled);
+};
+/** Intent status after its tenders change (`LOCKED` → `COMPLETED`). */
+const nextIntentStatus = (intent, paymentStatus) => {
+	if (intent.status !== "LOCKED") return intent.status;
+	if (paymentStatus === "PAID" || paymentStatus === "REFUNDED") return "COMPLETED";
+	return intent.status;
+};
+const RESOLVED_STATUSES = [
+	"PAID",
+	"FAILED",
+	"CANCELLED",
+	"REFUNDED"
+];
+const isPartialApproval = (tender, update) => {
+	if (update.status !== "PAID") return false;
+	if (update.approved_amount === void 0) return false;
+	const tolerance = amountTolerance(tender.amount.currency);
+	return update.approved_amount + tolerance < tender.amount.total;
+};
+const withAttempt = (tender, reference) => {
+	if (tender.attempt_reference === reference) return tender;
+	const previous = [...tender.previous_attempt_references, tender.attempt_reference];
+	return {
+		...tender,
+		attempt_reference: reference,
+		previous_attempt_references: previous
+	};
+};
+const sameJson = (left, right) => {
+	return JSON.stringify(left) === JSON.stringify(right);
+};
+const replaceTender = (intent, tender) => {
+	const tenders = intent.tenders.map((item) => {
+		return item.id === tender.id ? tender : item;
+	});
+	return {
+		...intent,
+		tenders
+	};
+};
+const flagReview = (intent, tender, update) => {
+	const at = update.at ?? (/* @__PURE__ */ new Date()).toISOString();
+	const late_report = {
+		status: update.status,
+		at,
+		attempt_reference: update.attempt_reference
+	};
+	const metadata = {
+		...tender.metadata,
+		needs_review: true,
+		late_report
+	};
+	const next = {
+		...tender,
+		metadata
+	};
+	const flagged = {
+		outcome: "NEEDS_REVIEW",
+		partialApproval: false
+	};
+	if (sameJson(tender, next)) return {
+		...flagged,
+		intent,
+		tender
+	};
+	return {
+		...flagged,
+		intent: replaceTender(intent, next),
+		tender: next
+	};
+};
+/**
+* Applies one tender result to its intent. Idempotent by the tender
+* `attempt_reference`; a new reference is accepted only as a retry of an
+* `IDLE` / `FAILED` tender (D25). A partial approval becomes `FAILED`
+* (D31). A late `PAID` after `CANCELLED` keeps the tender cancelled and is
+* flagged `NEEDS_REVIEW`.
+*/
+const mergePaymentTender = (intent, update) => {
+	const current = intent.tenders.find((item) => item.id === update.tender_id);
+	const none = {
+		intent,
+		tender: null,
+		partialApproval: false
+	};
+	if (!current) return {
+		outcome: "NOT_FOUND",
+		...none
+	};
+	const reference = update.attempt_reference;
+	const keep = {
+		intent,
+		tender: current,
+		partialApproval: false
+	};
+	if (current.previous_attempt_references.includes(reference)) {
+		if (update.status !== "PAID") return {
+			outcome: "IGNORED",
+			...keep
+		};
+		return flagReview(intent, current, update);
+	}
+	const isRetry = current.attempt_reference !== reference;
+	const retryable = current.status === "IDLE" || current.status === "FAILED";
+	if (isRetry && !retryable) return {
+		outcome: "IGNORED",
+		...keep
+	};
+	const partialApproval = isPartialApproval(current, update);
+	const status = partialApproval ? "FAILED" : update.status;
+	if (!NEXT_STATUSES[current.status].includes(status)) {
+		if (current.status === "CANCELLED" && status === "PAID") return flagReview(intent, current, update);
+		return {
+			outcome: "IGNORED",
+			...keep
+		};
+	}
+	const at = update.at ?? (/* @__PURE__ */ new Date()).toISOString();
+	const metadata = {
+		...current.metadata,
+		...update.metadata
+	};
+	if (update.provider_reference) metadata.provider_reference = update.provider_reference;
+	if (partialApproval) metadata.partial_approval = { approved_amount: update.approved_amount };
+	const base = withAttempt(current, reference);
+	const details = update.details === void 0 ? base.details : update.details;
+	let error_message = update.error_message ?? base.error_message;
+	if (partialApproval) error_message = PARTIAL_APPROVAL_ERROR;
+	const resolved_at = RESOLVED_STATUSES.includes(status) ? base.resolved_at ?? at : base.resolved_at;
+	const b1 = {
+		status,
+		details,
+		error_message,
+		metadata,
+		resolved_at
+	};
+	const next = {
+		...base,
+		...b1
+	};
+	if (sameJson(current, next)) return {
+		outcome: "UNCHANGED",
+		...keep
+	};
+	const merged = replaceTender(intent, next);
+	const paymentStatus = derivePaymentStatus(merged);
+	const intentStatus = nextIntentStatus(merged, paymentStatus);
+	return {
+		outcome: "APPLIED",
+		intent: {
+			...merged,
+			status: intentStatus
+		},
+		tender: next,
+		partialApproval
+	};
+};
+//#endregion
+//#region src/allocation.ts
+/** `metadata.fee_based_on` values that are a tip (always primary, D18). */
+const TIP_FEE_BASED_ON = ["TIPS"];
+/** `metadata.fee_based_on` values that are delivery (always primary, D18). */
+const DELIVERY_FEE_BASED_ON = [
+	"DISTANCE_STRAIGHT",
+	"DISTANCE_STREET",
+	"COVERAGE_ZONE_TAG"
+];
+const zeroMinor = () => ({
+	subtotal: 0,
+	discount: 0,
+	tax: 0,
+	total: 0
+});
+const addMinor = (left, right) => {
+	return {
+		subtotal: left.subtotal + right.subtotal,
+		discount: left.discount + right.discount,
+		tax: left.tax + right.tax,
+		total: left.total + right.total
+	};
+};
+const feeBasedOf = (line) => {
+	const value = line.metadata?.fee_based_on;
+	return typeof value === "string" ? value : null;
+};
+/** Tip fee line (`metadata.fee_based_on = TIPS`). */
+const isTipFee = (line) => {
+	const based = feeBasedOf(line);
+	return line.type === "FEE" && based !== null && TIP_FEE_BASED_ON.includes(based);
+};
+/** Delivery fee line (distance or coverage zone based). */
+const isDeliveryFee = (line) => {
+	const based = feeBasedOf(line);
+	if (line.type !== "FEE" || based === null) return false;
+	return DELIVERY_FEE_BASED_ON.includes(based);
+};
+const fail = (code, message, extra = {}) => {
+	return { fail: {
+		code,
+		message,
+		...extra
+	} };
+};
+const isFail = (value) => {
+	return typeof value === "object" && value !== null && "fail" in value;
+};
+const descendantsOf = (lines, rootUid) => {
+	const out = [];
+	const queue = [rootUid];
+	while (queue.length > 0) {
+		const parent = queue.shift();
+		for (const line of lines) {
+			if (line.parent_uid !== parent) continue;
+			out.push(line);
+			queue.push(line.uid);
+		}
+	}
+	return out;
+};
+/**
+* Splits `amount` (minor units) by `units / quantity` per part. Each part
+* gets the floor of its exact share; the residual goes one minor unit at a
+* time to the largest discarded fraction, ties to the lowest `sequence`.
+*/
+const prorateMinor = (amount, quantity, parts) => {
+	const shares = parts.map((part, index) => {
+		const numerator = amount * part.units;
+		const base = Math.floor(numerator / quantity);
+		return {
+			index,
+			base,
+			remainder: numerator - base * quantity,
+			sequence: part.sequence
+		};
+	});
+	let residual = amount - shares.reduce((sum, share) => sum + share.base, 0);
+	const order = shares.toSorted((a, b) => {
+		if (b.remainder !== a.remainder) return b.remainder - a.remainder;
+		return a.sequence - b.sequence;
+	});
+	const out = shares.map((share) => share.base);
+	for (const share of order) {
+		if (residual <= 0) break;
+		out[share.index] = (out[share.index] ?? 0) + 1;
+		residual -= 1;
+	}
+	return out;
+};
+const createConverter = (currency) => {
+	const factor = 10 ** currencyDecimals(currency);
+	const toMinor = (value) => Math.round(value * factor);
+	const fromMinor = (value) => value / factor;
+	return {
+		toMinor,
+		fromMinor
+	};
+};
+const planAllocations = (input, real, roots) => {
+	const byUid = new Map(input.lines.map((line) => [line.uid, line]));
+	const plan = {
+		whole: /* @__PURE__ */ new Map(),
+		parts: /* @__PURE__ */ new Map(),
+		fees: /* @__PURE__ */ new Map()
+	};
+	const primaryIndex = 0;
+	for (const [tenderIndex, tender] of real.entries()) {
+		const allocation = tender.allocation;
+		if (!allocation) continue;
+		const tender_id = tender.id;
+		const seen = /* @__PURE__ */ new Set();
+		for (const item of allocation.lines ?? []) {
+			const line = byUid.get(item.line_uid);
+			const ref = {
+				tender_id,
+				line_uid: item.line_uid
+			};
+			if (!line) return fail("PAYMENT_INVALID_ALLOCATION", "Unknown line", ref);
+			if (line.parent_uid !== null) return fail("PAYMENT_INVALID_ALLOCATION", "Child lines are allocated with their parent", ref);
+			if (line.type === "FEE") return fail("PAYMENT_INVALID_ALLOCATION", "Fees are allocated in allocation.fees", ref);
+			if (seen.has(line.uid)) return fail("PAYMENT_INVALID_ALLOCATION", "A line appears twice in one tender", ref);
+			seen.add(line.uid);
+			if (item.units === void 0) {
+				if (plan.whole.has(line.uid) || plan.parts.has(line.uid)) return fail("PAYMENT_UNALLOCATED_LINES", "Line allocated more than once", ref);
+				plan.whole.set(line.uid, tenderIndex);
+				continue;
+			}
+			if (!(Number.isInteger(line.quantity) && line.quantity > 1)) return fail("PAYMENT_INVALID_ALLOCATION", "Only integer quantities above 1 can be split", ref);
+			if (plan.whole.has(line.uid)) return fail("PAYMENT_UNALLOCATED_LINES", "Line allocated more than once", ref);
+			const parts = plan.parts.get(line.uid) ?? [];
+			const sequence = tender.sequence;
+			parts.push({
+				tenderIndex,
+				units: item.units,
+				sequence
+			});
+			plan.parts.set(line.uid, parts);
+		}
+		for (const uid of allocation.fees ?? []) {
+			const line = byUid.get(uid);
+			const ref = {
+				tender_id,
+				line_uid: uid
+			};
+			const isFee = line?.type === "FEE" && line.parent_uid === null;
+			if (!line || !isFee) return fail("PAYMENT_INVALID_ALLOCATION", "Unknown fee", ref);
+			if ((isTipFee(line) || isDeliveryFee(line)) && tenderIndex !== primaryIndex) return fail("PAYMENT_INVALID_ALLOCATION", "Tip and delivery go to the primary tender", ref);
+			if (plan.fees.has(uid)) return fail("PAYMENT_UNALLOCATED_LINES", "Fee allocated more than once", ref);
+			plan.fees.set(uid, tenderIndex);
+		}
+	}
+	const openIndex = real.findIndex((tender) => tender.allocation === null);
+	for (const root of roots) {
+		const ref = { line_uid: root.uid };
+		if (root.type === "FEE") {
+			if (!plan.fees.has(root.uid)) {
+				const target = openIndex >= 0 ? openIndex : primaryIndex;
+				const primaryOnly = isTipFee(root) || isDeliveryFee(root);
+				plan.fees.set(root.uid, primaryOnly ? primaryIndex : target);
+			}
+			continue;
+		}
+		if (plan.whole.has(root.uid)) continue;
+		const parts = plan.parts.get(root.uid);
+		const assigned = (parts ?? []).reduce((sum, part) => sum + part.units, 0);
+		const missing = root.quantity - assigned;
+		if (missing === 0) continue;
+		const msg = "Line units do not add up to its quantity";
+		if (missing < 0) return fail("PAYMENT_UNALLOCATED_LINES", msg, ref);
+		if (openIndex < 0) return fail("PAYMENT_UNALLOCATED_LINES", msg, ref);
+		if (!parts) {
+			plan.whole.set(root.uid, openIndex);
+			continue;
+		}
+		if (parts.some((part) => part.tenderIndex === openIndex)) return fail("PAYMENT_UNALLOCATED_LINES", msg, ref);
+		const sequence = real[openIndex]?.sequence ?? 0;
+		parts.push({
+			tenderIndex: openIndex,
+			units: missing,
+			sequence
+		});
+	}
+	for (const [uid, parts] of plan.parts) {
+		if (parts.length >= 2) continue;
+		return fail("PAYMENT_INVALID_ALLOCATION", "A split line must be in two or more tenders", { line_uid: uid });
+	}
+	return plan;
+};
+const ownMinor = (line, toMinor) => {
+	return {
+		subtotal: toMinor(line.subtotal),
+		discount: toMinor(line.discount_total),
+		tax: toMinor(line.tax_total),
+		total: toMinor(line.total)
+	};
+};
+const groupMinor = (line, toMinor) => {
+	return {
+		subtotal: toMinor(line.group_subtotal),
+		discount: toMinor(line.group_discount),
+		tax: toMinor(line.group_tax_total),
+		total: toMinor(line.group_total)
+	};
+};
+const isConsistent = (value) => {
+	return Math.abs(value.subtotal - value.discount + value.tax - value.total) <= 1;
+};
+/** Split of one component per part; `tax = total − subtotal + discount`. */
+const splitComponent = (value, quantity, parts) => {
+	const subtotal = prorateMinor(value.subtotal, quantity, parts);
+	const discount = prorateMinor(value.discount, quantity, parts);
+	const total = prorateMinor(value.total, quantity, parts);
+	return parts.map((_, index) => {
+		const s = subtotal[index] ?? 0;
+		const d = discount[index] ?? 0;
+		const t = total[index] ?? 0;
+		return {
+			subtotal: s,
+			discount: d,
+			tax: t - s + d,
+			total: t
+		};
+	});
+};
+const base = (tender) => {
+	return {
+		id: tender.id,
+		sequence: tender.sequence,
+		method: tender.method
+	};
+};
+const emptyAmount = (currency, total) => {
+	const b1 = {
+		currency,
+		subtotal: total,
+		discount_total: 0,
+		tax_total: 0
+	};
+	const b2 = {
+		fees: 0,
+		tip: 0,
+		delivery: 0,
+		redemptions_applied: 0
+	};
+	return {
+		...b1,
+		...b2,
+		total
+	};
+};
+/**
+* Server-side money of every tender (§3.2): whole lines as stored, parts
+* prorated per component with the residual minor unit to the largest
+* discarded fraction, fees to their tender, tip / delivery and order-level
+* adjustments to the primary, then REDEMPTION deducted from the primary
+* first and by `sequence`, never below a tender's tip + delivery (D18).
+*/
+const allocateTenders = (input) => {
+	const currency = input.totals.currency;
+	const { toMinor, fromMinor } = createConverter(currency);
+	const sorted = input.tenders.toSorted((a, b) => a.sequence - b.sequence);
+	const real = sorted.filter((tender) => isRealPaymentMethod(tender.method));
+	const redemptions = sorted.filter((tender) => {
+		return !isRealPaymentMethod(tender.method);
+	});
+	const roots = input.lines.filter((line) => line.parent_uid === null);
+	const orderTotal = toMinor(input.totals.total);
+	const tipDelivery = roots.reduce((sum, line) => {
+		return isTipFee(line) || isDeliveryFee(line) ? sum + toMinor(line.group_total) : sum;
+	}, 0);
+	const redemptionMinor = redemptions.map((tender) => {
+		return toMinor(tender.redemption_amount ?? 0);
+	});
+	const redeemed = redemptionMinor.reduce((sum, value) => sum + value, 0);
+	if (redeemed > orderTotal - tipDelivery) return {
+		ok: false,
+		error: {
+			code: "PAYMENT_REDEMPTION_EXCEEDED",
+			message: "Redemptions exceed the order total minus tip and delivery"
+		}
+	};
+	const openTenders = real.filter((tender) => tender.allocation === null);
+	if (openTenders.length > 1) return {
+		ok: false,
+		error: {
+			code: "PAYMENT_UNALLOCATED_LINES",
+			message: "Only one real tender can omit its allocation",
+			tender_id: openTenders[1]?.id
+		}
+	};
+	const redemptionTenders = redemptions.map((tender, index) => {
+		const value = fromMinor(redemptionMinor[index] ?? 0);
+		const amount = emptyAmount(currency, value);
+		return {
+			...base(tender),
+			allocation: null,
+			amount
+		};
+	});
+	if (real.length === 0) {
+		if (redeemed !== orderTotal) {
+			const msg = "Redemptions must cover the order without a real tender";
+			let code = "PAYMENT_UNALLOCATED_LINES";
+			if (redeemed > orderTotal) code = "PAYMENT_REDEMPTION_EXCEEDED";
+			return {
+				ok: false,
+				error: {
+					code,
+					message: msg
+				}
+			};
+		}
+		return {
+			ok: true,
+			tenders: redemptionTenders,
+			primary_tender_id: null
+		};
+	}
+	const plan = planAllocations(input, real, roots);
+	if (isFail(plan)) return {
+		ok: false,
+		error: plan.fail
+	};
+	const builds = real.map(() => {
+		return {
+			products: zeroMinor(),
+			fees: 0,
+			tip: 0,
+			delivery: 0,
+			amounts: []
+		};
+	});
+	const toAmount = (uid, value, units) => {
+		const subtotal = fromMinor(value.subtotal);
+		const discount = fromMinor(value.discount);
+		const b1 = {
+			tax: fromMinor(value.tax),
+			total: fromMinor(value.total)
+		};
+		return {
+			line_uid: uid,
+			...units === void 0 ? {} : { units },
+			subtotal,
+			discount,
+			...b1
+		};
+	};
+	for (const root of roots) {
+		if (root.type === "FEE") {
+			const build = builds[plan.fees.get(root.uid) ?? 0];
+			const total = toMinor(root.group_total);
+			if (isTipFee(root)) build.tip += total;
+			else if (isDeliveryFee(root)) build.delivery += total;
+			else build.fees += total;
+			const amount = toAmount(root.uid, groupMinor(root, toMinor));
+			build.amounts.push({
+				...amount,
+				children: []
+			});
+			continue;
+		}
+		const children = descendantsOf(input.lines, root.uid);
+		const wholeIndex = plan.whole.get(root.uid);
+		if (wholeIndex !== void 0) {
+			const build = builds[wholeIndex];
+			const group = groupMinor(root, toMinor);
+			build.products = addMinor(build.products, group);
+			const childAmounts = children.map((child) => {
+				const own = ownMinor(child, toMinor);
+				return {
+					...toAmount(child.uid, own),
+					quantity: child.quantity
+				};
+			});
+			const amount = toAmount(root.uid, group);
+			build.amounts.push({
+				...amount,
+				children: childAmounts
+			});
+			continue;
+		}
+		const parts = plan.parts.get(root.uid) ?? [];
+		const components = [root, ...children];
+		const splits = [];
+		for (const component of components) {
+			const own = ownMinor(component, toMinor);
+			if (!isConsistent(own)) return {
+				ok: false,
+				error: {
+					code: "PAYMENT_LINE_NOT_SPLITTABLE",
+					message: "Line amounts are not consistent; it cannot be split",
+					line_uid: root.uid
+				}
+			};
+			splits.push(splitComponent(own, root.quantity, parts));
+		}
+		for (const [partIndex, part] of parts.entries()) {
+			const build = builds[part.tenderIndex];
+			const shares = splits.map((split) => split[partIndex] ?? zeroMinor());
+			const value = shares.reduce(addMinor, zeroMinor());
+			build.products = addMinor(build.products, value);
+			const childAmounts = children.map((child, childIndex) => {
+				const share = shares[childIndex + 1] ?? zeroMinor();
+				const quantity = child.quantity * part.units / root.quantity;
+				return {
+					...toAmount(child.uid, share),
+					quantity
+				};
+			});
+			const amount = toAmount(root.uid, value, part.units);
+			build.amounts.push({
+				...amount,
+				children: childAmounts
+			});
+		}
+	}
+	const allocated = builds.reduce((sum, build) => {
+		return sum + build.products.total + build.fees + build.tip + build.delivery;
+	}, 0);
+	const primary = builds[0];
+	const adjustment = orderTotal - allocated;
+	if (adjustment < 0) {
+		const value = { ...primary.products };
+		value.discount -= adjustment;
+		value.total += adjustment;
+		primary.products = value;
+	} else if (adjustment > 0) primary.products = {
+		...primary.products,
+		total: primary.products.total + adjustment
+	};
+	const totals = builds.map((build) => {
+		return build.products.total + build.fees + build.tip + build.delivery;
+	});
+	if ((totals[0] ?? 0) < 0) return {
+		ok: false,
+		error: {
+			code: "PAYMENT_INVALID_PRIMARY",
+			message: "Order discounts leave the primary tender below zero",
+			tender_id: real[0]?.id
+		}
+	};
+	const applied = builds.map(() => 0);
+	let pending = redeemed;
+	for (const [index, build] of builds.entries()) {
+		if (pending <= 0) break;
+		const floor = build.tip + build.delivery;
+		const room = Math.max(0, (totals[index] ?? 0) - floor);
+		const take = Math.min(room, pending);
+		applied[index] = take;
+		pending -= take;
+	}
+	if (pending > 0) return {
+		ok: false,
+		error: {
+			code: "PAYMENT_REDEMPTION_EXCEEDED",
+			message: "Redemptions exceed what real tenders can absorb"
+		}
+	};
+	return {
+		ok: true,
+		tenders: [...real.map((tender, index) => {
+			const build = builds[index];
+			const total = (totals[index] ?? 0) - (applied[index] ?? 0);
+			const b1 = {
+				currency,
+				subtotal: fromMinor(build.products.subtotal)
+			};
+			const b2 = { discount_total: fromMinor(build.products.discount) };
+			const b3 = { tax_total: fromMinor(build.products.tax) };
+			const b4 = {
+				fees: fromMinor(build.fees),
+				tip: fromMinor(build.tip)
+			};
+			const b5 = { delivery: fromMinor(build.delivery) };
+			const b6 = { redemptions_applied: fromMinor(applied[index] ?? 0) };
+			const amount = {
+				...b1,
+				...b2,
+				...b3,
+				...b4,
+				...b5,
+				...b6,
+				total: fromMinor(total)
+			};
+			const open = tender.allocation === null;
+			const lines = open ? [] : tender.allocation?.lines ?? [];
+			const fees = open ? [] : tender.allocation?.fees ?? [];
+			let allocation = null;
+			if (real.length > 1 || !open) allocation = {
+				lines,
+				fees,
+				amounts: build.amounts
+			};
+			return {
+				...base(tender),
+				allocation,
+				amount
+			};
+		}), ...redemptionTenders].toSorted((a, b) => {
+			return a.sequence - b.sequence;
+		}),
+		primary_tender_id: real[0]?.id ?? null
+	};
+};
+/**
+* Items of one real tender (D8): whole `PRODUCT` parent lines plus each
+* part (1 each). Children, fees and REDEMPTION never count; units do not
+* add up. `null` allocation = every product parent line.
+*/
+const countTenderItems = (allocation, lines) => {
+	const products = lines.filter((line) => {
+		return line.parent_uid === null && line.type === "PRODUCT";
+	});
+	if (!allocation) return products.length;
+	const uids = new Set(products.map((line) => line.uid));
+	return (allocation.lines ?? []).filter((item) => uids.has(item.line_uid)).length;
+};
+/**
+* Mixed payments rules over real tenders only (D17): a REDEMPTION never
+* makes an order mixed, counts as a method, an item or an amount.
+*/
+const validateTendersAgainstRules = (input) => {
+	const real = input.tenders.filter((tender) => {
+		return isRealPaymentMethod(tender.method);
+	});
+	const is_mixed = real.length >= 2;
+	if (!is_mixed) return {
+		ok: true,
+		is_mixed
+	};
+	const effect = input.effect;
+	if (!effect?.enabled) return {
+		ok: false,
+		error: {
+			code: "MIXED_PAYMENTS_DISABLED",
+			message: "Mixed payments are not enabled",
+			reason: "RULE_DISABLED"
+		}
+	};
+	if (new Set(real.map((tender) => tender.method)).size > effect.max_methods) return {
+		ok: false,
+		error: {
+			code: "PAYMENT_TOO_MANY_METHODS",
+			message: `At most ${effect.max_methods} payment methods`
+		}
+	};
+	for (const tender of real) {
+		const caps = effect.per_method[tender.method];
+		const maxItems = caps?.max_items ?? effect.max_items_per_method;
+		const items = countTenderItems(tender.allocation, input.lines);
+		const tender_id = tender.id;
+		if (maxItems !== null && items > maxItems) return {
+			ok: false,
+			error: {
+				code: "PAYMENT_TOO_MANY_ITEMS",
+				message: `At most ${maxItems} items per payment method`,
+				tender_id
+			}
+		};
+		const maxAmount = caps?.max_amount ?? effect.max_amount_per_method;
+		const tolerance = amountTolerance(tender.amount.currency);
+		if (maxAmount !== null && tender.amount.total > maxAmount + tolerance) return {
+			ok: false,
+			error: {
+				code: "PAYMENT_AMOUNT_EXCEEDED",
+				message: `At most ${maxAmount} per payment method`,
+				tender_id
+			}
+		};
+	}
+	return {
+		ok: true,
+		is_mixed
+	};
+};
+//#endregion
 //#region src/device.ts
 const isEmpty = (value) => {
 	return value == null || typeof value === "string" && value.trim() === "";
@@ -383,4 +1267,4 @@ const memoryPaymentStorage = () => {
 	};
 };
 //#endregion
-export { CURRENCY_DECIMALS, DEFAULT_PAYMENT_POLICY, PAYMENT_ERROR_CODES, PAYMENT_ERROR_DEFAULTS, PaymentError, amountTolerance, batchCloseDay, createAttemptReference, createPaymentError, currencyDecimals, defaultReversalFor, definePaymentErrors, formatPaymentError, isBatchCloseDue, isPaymentError, isTerminalLocked, memoryPaymentStorage, missingDeviceFields, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, scopedPaymentStorage, taxBreakdown, toChargeAmount, toPaymentAmount, toPaymentError, withTerminalLock };
+export { ACTIVE_INTENT_STATUSES, CURRENCY_DECIMALS, DEFAULT_PAYMENT_POLICY, DELIVERY_FEE_BASED_ON, DIGITAL_COLLECT_AT, NEXT_STATUSES, PARTIAL_APPROVAL_ERROR, PAYMENT_ERROR_CODES, PAYMENT_ERROR_DEFAULTS, PaymentError, REDEMPTION_METHOD, TERMINAL_TENDER_STATUSES, TIP_FEE_BASED_ON, activeIntent, allocateTenders, amountTolerance, batchCloseDay, countTenderItems, createAttemptReference, createPaymentError, currencyDecimals, currentIntent, defaultReversalFor, definePaymentErrors, derivePaymentStatus, formatPaymentError, isBatchCloseDue, isDeliveryFee, isIntentCovered, isMixedTenders, isPaymentError, isRealPaymentMethod, isRedemptionReserved, isScopePaid, isTenderSettled, isTerminalLocked, isTipFee, liveRealTenders, liveTenders, memoryPaymentStorage, mergePaymentTender, missingDeviceFields, nextIntentStatus, primaryTender, primaryTenderOf, prorateMinor, realTenders, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, scopedPaymentStorage, taxBreakdown, tendersCoverage, tendersInScope, toChargeAmount, toPaymentAmount, toPaymentError, validateTendersAgainstRules, withTerminalLock };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fire-spark/payments",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Fire Spark payments contract: adapters, errors, amounts and policy",
   "type": "module",
   "sideEffects": false,
@@ -17,7 +17,7 @@
     }
   },
   "dependencies": {
-    "@fire-spark/types": "^0.2.0"
+    "@fire-spark/types": "^0.3.0"
   },
   "devDependencies": {
     "tsdown": "^0.22.14",