@paytree/medusa-payment-paytree 0.1.0

package/dist/modules/paytree/service.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const paytree_setting_1 = require("./models/paytree-setting");
+const paytree_event_log_1 = require("./models/paytree-event-log");
+const SETTINGS_ID = "paytree_settings";
+/**
+ * Service for the `paytree` module. Resolvable from app-level API routes and
+ * subscribers (not from the isolated payment provider — that path reads the
+ * table directly). Exposes settings get/upsert and audit-log queries used by
+ * the admin UI.
+ */
+class PaytreeService extends (0, utils_1.MedusaService)({
+    PaytreeSetting: paytree_setting_1.PaytreeSetting,
+    PaytreeEventLog: paytree_event_log_1.PaytreeEventLog,
+}) {
+    /** Return the single settings row, creating defaults if absent. */
+    async getSettings(defaults) {
+        const existing = await this.listPaytreeSettings({ id: SETTINGS_ID });
+        if (existing.length) {
+            return existing[0];
+        }
+        const [created] = await this.createPaytreeSettings([
+            {
+                id: SETTINGS_ID,
+                base_url: defaults.base_url,
+                log_request: defaults.log_request ?? false,
+                log_response: defaults.log_response ?? false,
+                methods: null,
+            },
+        ]);
+        return created;
+    }
+    /** Upsert the single settings row. */
+    async upsertSettings(values) {
+        // `methods` is a JSONB array; the generated model types it as an object, so
+        // we widen to `any` for the persistence call.
+        const payload = { id: SETTINGS_ID, ...values };
+        const existing = await this.listPaytreeSettings({ id: SETTINGS_ID });
+        if (existing.length) {
+            return this.updatePaytreeSettings(payload);
+        }
+        const [created] = await this.createPaytreeSettings([payload]);
+        return created;
+    }
+}
+exports.default = PaytreeService;

package/dist/modules/paytree-payment/index.d.ts

@@ -0,0 +1,8 @@
+import PaytreePaymentProviderService from "./service";
+/**
+ * Registers the Paytree payment provider with the Payment module.
+ * Reference this from medusa-config.ts under the payment module's `providers`.
+ */
+declare const _default: import("@medusajs/types").ModuleProviderExports;
+export default _default;
+export { PaytreePaymentProviderService };

package/dist/modules/paytree-payment/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaytreePaymentProviderService = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const service_1 = __importDefault(require("./service"));
+exports.PaytreePaymentProviderService = service_1.default;
+/**
+ * Registers the Paytree payment provider with the Payment module.
+ * Reference this from medusa-config.ts under the payment module's `providers`.
+ */
+exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.PAYMENT, {
+    services: [service_1.default],
+});

package/dist/modules/paytree-payment/lib/amount.d.ts

@@ -0,0 +1,23 @@
+import { BigNumber } from "@medusajs/framework/utils";
+import type { BigNumberInput } from "@medusajs/framework/types";
+/**
+ * Medusa v2 represents payment amounts in MAJOR units as BigNumber
+ * (e.g. 10.5 means 10.50 of the currency), unlike v1's minor units.
+ *
+ * Paytree's API accepts a decimal string limited to two decimal places
+ * (pattern: ^-?\d{0,8}(?:\.\d{0,2})?$). We therefore format to a fixed
+ * two-decimal string.
+ *
+ * Note: three-decimal currencies (BHD, KWD, OMR) are constrained by Paytree's
+ * own 2-decimal pattern, so amounts are rounded to 2 places to match the API.
+ */
+export declare function toPaytreeAmount(amount: BigNumberInput): string;
+/** Parse a Paytree decimal string back into a Medusa BigNumber. */
+export declare function fromPaytreeAmount(amount: string): BigNumber;
+/**
+ * Compute how much of a payment is newly refundable to record in Medusa,
+ * given the total refunded amount reported by Paytree and what Medusa has
+ * already recorded. Returns a non-negative decimal string, or null when
+ * there is nothing new to record.
+ */
+export declare function newlyRefundedAmount(paytreeRefundedTotal: string, alreadyRecorded: BigNumberInput): string | null;

package/dist/modules/paytree-payment/lib/amount.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPaytreeAmount = toPaytreeAmount;
+exports.fromPaytreeAmount = fromPaytreeAmount;
+exports.newlyRefundedAmount = newlyRefundedAmount;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Medusa v2 represents payment amounts in MAJOR units as BigNumber
+ * (e.g. 10.5 means 10.50 of the currency), unlike v1's minor units.
+ *
+ * Paytree's API accepts a decimal string limited to two decimal places
+ * (pattern: ^-?\d{0,8}(?:\.\d{0,2})?$). We therefore format to a fixed
+ * two-decimal string.
+ *
+ * Note: three-decimal currencies (BHD, KWD, OMR) are constrained by Paytree's
+ * own 2-decimal pattern, so amounts are rounded to 2 places to match the API.
+ */
+function toPaytreeAmount(amount) {
+    const value = new utils_1.BigNumber(amount);
+    return value.numeric.toFixed(2);
+}
+/** Parse a Paytree decimal string back into a Medusa BigNumber. */
+function fromPaytreeAmount(amount) {
+    return new utils_1.BigNumber(amount);
+}
+/**
+ * Compute how much of a payment is newly refundable to record in Medusa,
+ * given the total refunded amount reported by Paytree and what Medusa has
+ * already recorded. Returns a non-negative decimal string, or null when
+ * there is nothing new to record.
+ */
+function newlyRefundedAmount(paytreeRefundedTotal, alreadyRecorded) {
+    const total = new utils_1.BigNumber(paytreeRefundedTotal);
+    const recorded = new utils_1.BigNumber(alreadyRecorded);
+    const delta = utils_1.MathBN.sub(total.numeric, recorded.numeric);
+    if (utils_1.MathBN.lte(delta, 0)) {
+        return null;
+    }
+    return new utils_1.BigNumber(delta).numeric.toFixed(2);
+}

package/dist/modules/paytree-payment/lib/audit.d.ts

@@ -0,0 +1,26 @@
+import { AuditEventType } from "./constants";
+export interface AuditRecord {
+    event: AuditEventType;
+    /** Medusa payment session id (our transaction_ref). */
+    session_id?: string | null;
+    /** Paytree payment intent id. */
+    paytree_id?: string | null;
+    status?: string | null;
+    amount?: string | null;
+    currency?: string | null;
+    /** Free-form, already-safe summary. Redacted again defensively on write. */
+    detail?: Record<string, unknown> | null;
+    error?: string | null;
+}
+/**
+ * Writes to the shared `paytree_event_log` table via the container's Postgres
+ * connection. The `paytree` module owns the schema; the provider only inserts.
+ * Every payload is run through `redact` before it is written, so secrets and
+ * PII never land in the audit trail regardless of caller.
+ */
+export declare class AuditWriter {
+    private readonly container_;
+    constructor(container: any);
+    private getConnection;
+    write(record: AuditRecord): Promise<void>;
+}

package/dist/modules/paytree-payment/lib/audit.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditWriter = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const crypto_1 = require("crypto");
+const constants_1 = require("./constants");
+const redact_1 = require("./redact");
+/**
+ * Writes to the shared `paytree_event_log` table via the container's Postgres
+ * connection. The `paytree` module owns the schema; the provider only inserts.
+ * Every payload is run through `redact` before it is written, so secrets and
+ * PII never land in the audit trail regardless of caller.
+ */
+class AuditWriter {
+    constructor(container) {
+        this.container_ = container;
+    }
+    getConnection() {
+        try {
+            return this.container_.resolve(utils_1.ContainerRegistrationKeys.PG_CONNECTION);
+        }
+        catch {
+            return this.container_?.[utils_1.ContainerRegistrationKeys.PG_CONNECTION] ?? null;
+        }
+    }
+    async write(record) {
+        const knex = this.getConnection();
+        if (!knex) {
+            return;
+        }
+        try {
+            await knex(constants_1.EVENT_LOG_TABLE).insert({
+                id: `ptlog_${(0, crypto_1.randomUUID)()}`,
+                event: record.event,
+                session_id: record.session_id ?? null,
+                paytree_id: record.paytree_id ?? null,
+                status: record.status ?? null,
+                amount: record.amount ?? null,
+                currency: record.currency ?? null,
+                detail: record.detail ? JSON.stringify((0, redact_1.redact)(record.detail)) : null,
+                error: record.error ?? null,
+                created_at: new Date(),
+            });
+        }
+        catch {
+            // Audit logging must never break a payment. Swallow write failures;
+            // the structured logger still captures the event in stdout.
+        }
+    }
+}
+exports.AuditWriter = AuditWriter;

package/dist/modules/paytree-payment/lib/client.d.ts

@@ -0,0 +1,28 @@
+import { PaytreeLogger, Correlation } from "./logger";
+import { PaytreeCreateIntentBody, PaytreeCreateIntentResponse, PaytreePaymentIntent } from "./types";
+export interface PaytreeClientConfig {
+    apiKey: string;
+    baseUrl: string;
+    logRequest: boolean;
+    logResponse: boolean;
+}
+/**
+ * Thin REST client over the Paytree API. One instance is created per call with
+ * the effective settings (so a base-URL change in the admin UI takes effect
+ * without a restart). The API key comes from env, never the DB.
+ */
+export declare class PaytreeClient {
+    private readonly cfg_;
+    private readonly logger_;
+    constructor(cfg: PaytreeClientConfig, logger: PaytreeLogger);
+    private url;
+    private request;
+    createPaymentIntent(body: PaytreeCreateIntentBody, c?: Correlation): Promise<PaytreeCreateIntentResponse>;
+    getPaymentIntent(id: string, c?: Correlation): Promise<PaytreePaymentIntent>;
+    /**
+     * Look up a payment intent by our own transaction_ref. This is the reliable
+     * way to read status without depending on Paytree's id (which is an integer
+     * in the create response but a UUID on retrieve). Returns null if not found.
+     */
+    findByTransactionRef(transactionRef: string, c?: Correlation): Promise<PaytreePaymentIntent | null>;
+}

package/dist/modules/paytree-payment/lib/client.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaytreeClient = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Thin REST client over the Paytree API. One instance is created per call with
+ * the effective settings (so a base-URL change in the admin UI takes effect
+ * without a restart). The API key comes from env, never the DB.
+ */
+class PaytreeClient {
+    constructor(cfg, logger) {
+        this.cfg_ = cfg;
+        this.logger_ = logger;
+    }
+    url(path) {
+        const base = this.cfg_.baseUrl.replace(/\/+$/, "");
+        return `${base}${path}`;
+    }
+    async request(method, path, body, c) {
+        const headers = {
+            Authorization: `Token ${this.cfg_.apiKey}`,
+            "Content-Type": "application/json",
+        };
+        this.logger_.request(this.cfg_.logRequest, method, path, headers, body, c);
+        let res;
+        try {
+            res = await fetch(this.url(path), {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+            });
+        }
+        catch (e) {
+            this.logger_.error(`network error calling ${method} ${path}`, e, c);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Paytree request failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        const text = await res.text();
+        let parsed = undefined;
+        if (text) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = text;
+            }
+        }
+        this.logger_.response(this.cfg_.logResponse, method, path, res.status, parsed, c);
+        if (!res.ok) {
+            // Surface Paytree's response body in the error so the actual rejection
+            // reason (e.g. which field failed validation) is visible in the error
+            // logs, not only in the opt-in debug response line. The parsed body and
+            // status are also attached so callers can persist them to the audit log.
+            const detail = typeof parsed === "string" ? parsed : JSON.stringify(parsed ?? {});
+            const err = new utils_1.MedusaError(res.status === 401 || res.status === 403
+                ? utils_1.MedusaError.Types.NOT_ALLOWED
+                : utils_1.MedusaError.Types.UNEXPECTED_STATE, `Paytree ${method} ${path} returned ${res.status}: ${detail}`);
+            err.paytreeStatus = res.status;
+            err.paytreeResponse = parsed ?? null;
+            throw err;
+        }
+        return parsed;
+    }
+    createPaymentIntent(body, c) {
+        return this.request("POST", "/v1/transaction/payment_intent/", body, c);
+    }
+    getPaymentIntent(id, c) {
+        return this.request("GET", `/v1/transaction/payment_intent/${id}/`, undefined, c);
+    }
+    /**
+     * Look up a payment intent by our own transaction_ref. This is the reliable
+     * way to read status without depending on Paytree's id (which is an integer
+     * in the create response but a UUID on retrieve). Returns null if not found.
+     */
+    async findByTransactionRef(transactionRef, c) {
+        const query = encodeURIComponent(transactionRef);
+        const res = await this.request("GET", `/v1/transaction/payment_intent/?transaction_ref=${query}`, undefined, c);
+        const results = res?.results ?? [];
+        return results.find((r) => r.transaction_ref === transactionRef) ?? results[0] ?? null;
+    }
+}
+exports.PaytreeClient = PaytreeClient;

package/dist/modules/paytree-payment/lib/constants.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared constants for the Paytree integration.
+ *
+ * The provider identifier is what Medusa uses to build the provider id
+ * (`pp_<identifier>_<id>`) and the default webhook route. We use a custom
+ * GET callback route instead (see src/api/hooks/paytree), because Paytree
+ * sends a GET ping rather than a signed POST body.
+ */
+/** Registration name of the regular module that owns the settings + audit-log tables. */
+export declare const PAYTREE_MODULE = "paytree";
+/** `static identifier` of the payment provider service. */
+export declare const PAYTREE_PROVIDER_IDENTIFIER = "paytree";
+/** Database tables (owned by the `paytree` module migration). */
+export declare const SETTINGS_TABLE = "paytree_setting";
+export declare const EVENT_LOG_TABLE = "paytree_event_log";
+/** Single-row settings record id. We keep one global settings row. */
+export declare const SETTINGS_SINGLETON_ID = "paytree_settings";
+/** Default Paytree API origin. Overridable per-environment via the admin UI. */
+export declare const DEFAULT_BASE_URL = "https://api.paytree.tech";
+/** How long the provider caches settings read from the DB before re-reading. */
+export declare const SETTINGS_CACHE_TTL_MS = 15000;
+/**
+ * Paytree transaction statuses, as documented in the Paytree API.
+ * Kept as a const so the status map and audit log can reference them safely.
+ */
+export declare const PaytreeStatus: {
+    readonly PENDING: "pending";
+    readonly PARTIAL: "partial";
+    readonly SUCCESS: "success";
+    readonly FAILED: "failed";
+    readonly CANCELED: "canceled";
+    readonly EXPIRED: "expired";
+    readonly AUTHORIZED: "authorized";
+    readonly REFUNDED: "refunded";
+    readonly PARTIAL_REFUNDED: "partial_refunded";
+    readonly DISPUTED: "disputed";
+    readonly DISPUTED_WON: "disputed_won";
+    readonly DISPUTED_LOST: "disputed_lost";
+    readonly DISPUTED_CLOSE: "disputed_close";
+};
+export type PaytreeStatusValue = (typeof PaytreeStatus)[keyof typeof PaytreeStatus];
+/** Event types we persist to the audit log. */
+export declare const AuditEvent: {
+    readonly INITIATE: "initiate_payment";
+    readonly AUTHORIZE: "authorize_payment";
+    readonly CAPTURE: "capture_payment";
+    readonly REFUND: "refund_payment";
+    readonly CANCEL: "cancel_payment";
+    readonly STATUS_READ: "get_payment_status";
+    readonly WEBHOOK_RECEIVED: "webhook_received";
+    readonly WEBHOOK_PROCESSED: "webhook_processed";
+    readonly ERROR: "error";
+};
+export type AuditEventType = (typeof AuditEvent)[keyof typeof AuditEvent];

package/dist/modules/paytree-payment/lib/constants.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Shared constants for the Paytree integration.
+ *
+ * The provider identifier is what Medusa uses to build the provider id
+ * (`pp_<identifier>_<id>`) and the default webhook route. We use a custom
+ * GET callback route instead (see src/api/hooks/paytree), because Paytree
+ * sends a GET ping rather than a signed POST body.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditEvent = exports.PaytreeStatus = exports.SETTINGS_CACHE_TTL_MS = exports.DEFAULT_BASE_URL = exports.SETTINGS_SINGLETON_ID = exports.EVENT_LOG_TABLE = exports.SETTINGS_TABLE = exports.PAYTREE_PROVIDER_IDENTIFIER = exports.PAYTREE_MODULE = void 0;
+/** Registration name of the regular module that owns the settings + audit-log tables. */
+exports.PAYTREE_MODULE = "paytree";
+/** `static identifier` of the payment provider service. */
+exports.PAYTREE_PROVIDER_IDENTIFIER = "paytree";
+/** Database tables (owned by the `paytree` module migration). */
+exports.SETTINGS_TABLE = "paytree_setting";
+exports.EVENT_LOG_TABLE = "paytree_event_log";
+/** Single-row settings record id. We keep one global settings row. */
+exports.SETTINGS_SINGLETON_ID = "paytree_settings";
+/** Default Paytree API origin. Overridable per-environment via the admin UI. */
+exports.DEFAULT_BASE_URL = "https://api.paytree.tech";
+/** How long the provider caches settings read from the DB before re-reading. */
+exports.SETTINGS_CACHE_TTL_MS = 15_000;
+/**
+ * Paytree transaction statuses, as documented in the Paytree API.
+ * Kept as a const so the status map and audit log can reference them safely.
+ */
+exports.PaytreeStatus = {
+    PENDING: "pending",
+    PARTIAL: "partial",
+    SUCCESS: "success",
+    FAILED: "failed",
+    CANCELED: "canceled",
+    EXPIRED: "expired",
+    AUTHORIZED: "authorized",
+    REFUNDED: "refunded",
+    PARTIAL_REFUNDED: "partial_refunded",
+    DISPUTED: "disputed",
+    DISPUTED_WON: "disputed_won",
+    DISPUTED_LOST: "disputed_lost",
+    DISPUTED_CLOSE: "disputed_close",
+};
+/** Event types we persist to the audit log. */
+exports.AuditEvent = {
+    INITIATE: "initiate_payment",
+    AUTHORIZE: "authorize_payment",
+    CAPTURE: "capture_payment",
+    REFUND: "refund_payment",
+    CANCEL: "cancel_payment",
+    STATUS_READ: "get_payment_status",
+    WEBHOOK_RECEIVED: "webhook_received",
+    WEBHOOK_PROCESSED: "webhook_processed",
+    ERROR: "error",
+};

package/dist/modules/paytree-payment/lib/logger.d.ts

@@ -0,0 +1,27 @@
+export interface Correlation {
+    /** Medusa payment session id (our transaction_ref). */
+    sessionId?: string | null;
+    /** Paytree payment intent id. */
+    paytreeId?: string | null;
+}
+/**
+ * Wraps Medusa's logger. Every line carries the correlation ids so a single
+ * payment can be traced end to end (initiate -> redirect -> callback ->
+ * capture -> refund) by grepping the session or intent id.
+ *
+ * Request/response BODIES are only emitted when the corresponding admin toggle
+ * is on, and always after redaction. Operational lines (info/error) are always
+ * emitted.
+ */
+export declare class PaytreeLogger {
+    private readonly logger_;
+    constructor(container: any);
+    private tag;
+    info(message: string, c?: Correlation): void;
+    warn(message: string, c?: Correlation): void;
+    error(message: string, error: unknown, c?: Correlation): void;
+    /** Log an outbound request body, redacted, only when enabled. */
+    request(enabled: boolean, method: string, path: string, headers: Record<string, string>, body: unknown, c?: Correlation): void;
+    /** Log a response body, redacted, only when enabled. */
+    response(enabled: boolean, method: string, path: string, httpStatus: number, body: unknown, c?: Correlation): void;
+}

package/dist/modules/paytree-payment/lib/logger.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaytreeLogger = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const redact_1 = require("./redact");
+const PREFIX = "[paytree]";
+/**
+ * Wraps Medusa's logger. Every line carries the correlation ids so a single
+ * payment can be traced end to end (initiate -> redirect -> callback ->
+ * capture -> refund) by grepping the session or intent id.
+ *
+ * Request/response BODIES are only emitted when the corresponding admin toggle
+ * is on, and always after redaction. Operational lines (info/error) are always
+ * emitted.
+ */
+class PaytreeLogger {
+    constructor(container) {
+        let resolved;
+        try {
+            resolved = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        }
+        catch {
+            resolved = container?.logger;
+        }
+        this.logger_ =
+            resolved ??
+                {
+                    info: console.log,
+                    debug: console.debug,
+                    warn: console.warn,
+                    error: console.error,
+                };
+    }
+    tag(c) {
+        const parts = [];
+        if (c?.sessionId) {
+            parts.push(`session=${c.sessionId}`);
+        }
+        if (c?.paytreeId) {
+            parts.push(`intent=${c.paytreeId}`);
+        }
+        return parts.length ? ` (${parts.join(" ")})` : "";
+    }
+    info(message, c) {
+        this.logger_.info(`${PREFIX} ${message}${this.tag(c)}`);
+    }
+    warn(message, c) {
+        this.logger_.warn(`${PREFIX} ${message}${this.tag(c)}`);
+    }
+    error(message, error, c) {
+        const detail = error instanceof Error ? error.message : String(error);
+        this.logger_.error(`${PREFIX} ${message}: ${detail}${this.tag(c)}`);
+    }
+    /** Log an outbound request body, redacted, only when enabled. */
+    request(enabled, method, path, headers, body, c) {
+        if (!enabled) {
+            return;
+        }
+        const payload = JSON.stringify({
+            headers: (0, redact_1.redactHeaders)(headers),
+            body: (0, redact_1.redact)(body),
+        });
+        this.logger_.debug(`${PREFIX} -> ${method} ${path} ${payload}${this.tag(c)}`);
+    }
+    /** Log a response body, redacted, only when enabled. */
+    response(enabled, method, path, httpStatus, body, c) {
+        if (!enabled) {
+            return;
+        }
+        this.logger_.debug(`${PREFIX} <- ${method} ${path} ${httpStatus} ${JSON.stringify((0, redact_1.redact)(body))}${this.tag(c)}`);
+    }
+}
+exports.PaytreeLogger = PaytreeLogger;

package/dist/modules/paytree-payment/lib/methods.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Canonical list of payment methods Paytree supports, with their default
+ * display labels. The admin can, per method:
+ *   - toggle whether it is offered at checkout (`enabled`)
+ *   - override the label shown to the customer (`label`)
+ *
+ * The set of methods is fixed by Paytree; only `enabled` and `label` are
+ * stored in the DB. Resolving merges the stored config over these defaults so
+ * that adding a method here automatically surfaces it in the admin UI.
+ */
+export declare const PAYTREE_METHOD_DEFS: readonly [{
+    readonly method: "card";
+    readonly label: "Credit / debit card";
+}, {
+    readonly method: "paypal";
+    readonly label: "PayPal";
+}, {
+    readonly method: "klarna";
+    readonly label: "Klarna";
+}, {
+    readonly method: "ideal";
+    readonly label: "iDEAL";
+}, {
+    readonly method: "bancontact";
+    readonly label: "Bancontact";
+}, {
+    readonly method: "crypto";
+    readonly label: "Crypto";
+}, {
+    readonly method: "wire";
+    readonly label: "Bank transfer";
+}, {
+    readonly method: "trustly";
+    readonly label: "Trustly";
+}, {
+    readonly method: "kakaopay";
+    readonly label: "KakaoPay";
+}, {
+    readonly method: "p24";
+    readonly label: "Przelewy24";
+}, {
+    readonly method: "blik";
+    readonly label: "BLIK";
+}];
+export type PaytreeMethodId = (typeof PAYTREE_METHOD_DEFS)[number]["method"];
+/** What we persist per method (only the admin-editable bits). */
+export interface StoredMethodConfig {
+    method: string;
+    enabled: boolean;
+    label?: string;
+}
+/** Fully resolved method config used by the admin UI and store endpoint. */
+export interface ResolvedMethodConfig {
+    method: string;
+    enabled: boolean;
+    label: string;
+}
+/**
+ * Merge stored per-method config over the canonical defaults. Unknown stored
+ * methods are ignored; missing ones fall back to disabled with the default
+ * label. `card` is enabled by default so a fresh install has one working
+ * method until the admin curates the list.
+ */
+export declare function resolveMethods(stored?: StoredMethodConfig[] | null): ResolvedMethodConfig[];
+/**
+ * Normalize an incoming admin payload into the minimal stored shape, dropping
+ * unknown methods and blank label overrides.
+ */
+export declare function normalizeMethods(input?: StoredMethodConfig[] | null): StoredMethodConfig[];