@webbers/pay-payments-medusa 2.2.43 → 2.2.46

package/.medusa/server/src/providers/pay/core/pay-client.js

@@ -8,6 +8,7 @@ class PayClient {
     constructor(options, logger) {
         this.httpClient_ = new http_client_1.HttpClient({ options, logger });
         this.serviceId_ = options.slCode;
+        this.logger_ = logger;
     }
     /**
      * Create a new order.
@@ -84,35 +85,62 @@ class PayClient {
         });
     }
     /**
-     * Create the one-off direct debit
+     * Create a one-off direct debit mandate
      * @param data
      */
     async createDirectDebit(data) {
         if (this.httpClient_.testMode) {
-            console.log("createDirectDebit", data);
+            this.logger_.info(`createDirectDebit skipped ${JSON.stringify(data)}`);
         }
         else {
-            return await this.httpClient_.restApiV3Request({
+            return await this.httpClient_.apiRequest({
                 endpoint: constants_1.PayApiPath.DIRECT_DEBIT,
                 data: {
                     ...data,
                     serviceId: this.serviceId_,
+                    stats: {
+                        object: `${package_json_1.displayName}|version ${package_json_1.version}`,
+                    },
                 },
             });
         }
     }
     /**
-     * Create the one-off direct debit
-     * @param data
+     * Retrieve a direct debit by its reference id. Unlike the mandate query this
+     * endpoint returns the direct debit object itself, not a paginated envelope.
+     * @param directDebitId
      */
-    async getDirectDebitInfo(mandateId) {
-        return await this.httpClient_.restApiV3Request({
-            endpoint: constants_1.PayApiPath.DIRECT_DEBIT_INFO,
-            data: {
-                mandateId,
-            },
+    async getDirectDebitInfo(directDebitId) {
+        return await this.httpClient_.apiRequest({
+            endpoint: constants_1.PayApiPath.DIRECT_DEBIT_INFO.replace("{id}", directDebitId),
+            method: "GET",
+        });
+    }
+    /**
+     * Retrieve direct debit info by the mandate code
+     * @param mandateId
+     */
+    async getDirectDebitInfoByMandate(mandateId) {
+        return await this.httpClient_.apiRequest({
+            endpoint: constants_1.PayApiPath.DIRECT_DEBIT_INFO_BY_MANDATE.replace("{id}", mandateId),
+            method: "GET",
+        });
+    }
+    /**
+     * Delete a mandate so no further direct debits can be executed on it. Test
+     * mode never creates a mandate, so there is nothing to delete there.
+     * @param mandateId
+     */
+    async deleteDirectDebitMandate(mandateId) {
+        if (this.httpClient_.testMode) {
+            this.logger_.info(`deleteDirectDebitMandate skipped for mandate ${mandateId}`);
+            return;
+        }
+        await this.httpClient_.apiRequest({
+            endpoint: constants_1.PayApiPath.DIRECT_DEBIT_MANDATE.replace("{id}", mandateId),
+            method: "DELETE",
         });
     }
 }
 exports.PayClient = PayClient;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/providers/pay/services/pay-direct-debit.d.ts

@@ -1,8 +1,54 @@
+import { CustomerDTO, OrderDTO, SalesChannelDTO } from "@medusajs/framework/types";
+import { CancelPaymentInput, CancelPaymentOutput, CapturePaymentInput, CapturePaymentOutput, PaymentSessionDTO, RefundPaymentInput, RefundPaymentOutput, RetrievePaymentInput, RetrievePaymentOutput, UpdatePaymentInput, UpdatePaymentOutput } from "@medusajs/types";
 import PayBase from "../core/pay-base";
-import { PaymentOptions } from "../types";
+import { CreateDirectDebitRequest, PaymentOptions } from "../types";
+/**
+ * Direct debits are not created through the Pay. order API but through the
+ * mandate API (POST /directdebits/mandates). The mandate response is stored on
+ * the payment session data, its `code` is used to retrieve the authoritative
+ * direct debit state later. Collection status changes arrive through incasso
+ * exchanges handled by the direct-debit-exchange subscriber.
+ */
 declare class PayDirectDebitService extends PayBase {
     static identifier: string;
     get paymentCreateOptions(): PaymentOptions;
+    createPayOrderPayload(order: OrderDTO & {
+        customer: CustomerDTO;
+        sales_channel: SalesChannelDTO;
+    }, paymentSession: PaymentSessionDTO): Omit<CreateDirectDebitRequest, "serviceId">;
+    /**
+     * Creates the direct debit mandate when the payload is passed from the order
+     * created hook. The returned data replaces the session data wholesale, so the
+     * payload key is always stripped, persisting it back would create a second
+     * mandate on a later update.
+     */
+    updatePayment(input: UpdatePaymentInput): Promise<UpdatePaymentOutput>;
+    /**
+     * Retrieves payment details. Payments that hold a Pay. order or transaction
+     * id (created through the order API, or refunded) resolve through the base
+     * implementation, mandate based payments resolve through the mandate code.
+     */
+    retrievePayment(input: RetrievePaymentInput): Promise<RetrievePaymentOutput>;
+    /**
+     * A mandate based direct debit is revoked by deleting the mandate at Pay.,
+     * so a pending collection is never executed for a canceled payment. The
+     * order API abort only applies to payments that hold a Pay. order id.
+     */
+    cancelPayment(input: CancelPaymentInput): Promise<CancelPaymentOutput>;
+    /**
+     * A mandate based direct debit only counts as captured when Pay. reports the
+     * direct debit as collected. The state is always re-fetched from Pay., so a
+     * spoofed exchange cannot capture an uncollected payment.
+     */
+    capturePayment(input: CapturePaymentInput): Promise<CapturePaymentOutput>;
+    /**
+     * Refunds go through the regular transaction refund endpoint, using the Pay.
+     * transaction id of the collection. That id lives on the collected direct
+     * debit, not necessarily on the stored payment data, so it is resolved from
+     * the mandate when missing.
+     */
+    refundPayment(input: RefundPaymentInput): Promise<RefundPaymentOutput>;
+    protected readMandateId(data: Record<string, any>): string | undefined;
 }
 export default PayDirectDebitService;
 //# sourceMappingURL=pay-direct-debit.d.ts.map

package/.medusa/server/src/providers/pay/services/pay-direct-debit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pay-direct-debit.d.ts","sourceRoot":"","sources":["../../../../../../src/providers/pay/services/pay-direct-debit.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAC,cAAc,EAAsB,MAAM,UAAU,CAAA;AAE5D,cAAM,qBAAsB,SAAQ,OAAO;IACzC,MAAM,CAAC,UAAU,SAAkC;IAEnD,IAAI,oBAAoB,IAAI,cAAc,CASzC;CACF;AAED,eAAe,qBAAqB,CAAA"}
+{"version":3,"file":"pay-direct-debit.d.ts","sourceRoot":"","sources":["../../../../../../src/providers/pay/services/pay-direct-debit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAE,QAAQ,EAAE,eAAe,EAAC,MAAM,2BAA2B,CAAA;AAChF,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,iBAAiB,CAAA;AAExB,OAAO,OAAO,MAAM,kBAAkB,CAAA;AACtC,OAAO,EACL,wBAAwB,EAGxB,cAAc,EAEf,MAAM,UAAU,CAAA;AAGjB;;;;;;GAMG;AACH,cAAM,qBAAsB,SAAQ,OAAO;IACzC,MAAM,CAAC,UAAU,SAAkC;IAEnD,IAAI,oBAAoB,IAAI,cAAc,CASzC;IAED,qBAAqB,CACnB,KAAK,EAAE,QAAQ,GAAG;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,aAAa,EAAE,eAAe,CAAA;KAAC,EACzE,cAAc,EAAE,iBAAiB,GAChC,IAAI,CAAC,wBAAwB,EAAE,WAAW,CAAC;IAqD9C;;;;;OAKG;IACG,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAsC5E;;;;OAIG;IACG,eAAe,CACnB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,qBAAqB,CAAC;IAqBjC;;;;OAIG;IACG,aAAa,CACjB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,mBAAmB,CAAC;IA8B/B;;;;OAIG;IACG,cAAc,CAClB,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,oBAAoB,CAAC;IAqChC;;;;;OAKG;IACG,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAyC5E,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,SAAS;CAOvE;AAED,eAAe,qBAAqB,CAAA"}

package/.medusa/server/src/providers/pay/services/pay-direct-debit.js

@@ -3,8 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
 const pay_base_1 = __importDefault(require("../core/pay-base"));
 const types_1 = require("../types");
+const constants_1 = require("../core/constants");
+/**
+ * Direct debits are not created through the Pay. order API but through the
+ * mandate API (POST /directdebits/mandates). The mandate response is stored on
+ * the payment session data, its `code` is used to retrieve the authoritative
+ * direct debit state later. Collection status changes arrive through incasso
+ * exchanges handled by the direct-debit-exchange subscriber.
+ */
 class PayDirectDebitService extends pay_base_1.default {
     get paymentCreateOptions() {
         return {
@@ -15,7 +24,193 @@ class PayDirectDebitService extends pay_base_1.default {
                 "_pay",
         };
     }
+    createPayOrderPayload(order, paymentSession) {
+        const paymentMethodInput = (paymentSession.data?.paymentMethodInput ??
+            {});
+        const iban = paymentMethodInput.iban?.replace(/\s/g, "");
+        if (!iban) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Bank account number is missing.");
+        }
+        const fullName = [
+            order.billing_address?.first_name?.trim(),
+            order.billing_address?.last_name?.trim(),
+        ]
+            .filter(Boolean)
+            .join(" ");
+        const owner = (paymentMethodInput.accountHolder?.trim() ||
+            order.billing_address?.company?.trim() ||
+            fullName).substring(0, 64);
+        const payload = {
+            reference: order.display_id.toString(),
+            description: this.getPaymentDescription(order),
+            type: "SINGLE",
+            exchangeUrl: this.paymentCreateOptions.webhookUrl,
+            amount: {
+                value: Math.round(paymentSession.amount.valueOf() * 100),
+                currency: order.currency_code.toUpperCase(),
+            },
+            customer: {
+                email: paymentMethodInput.email || order.email || "",
+                bankAccount: {
+                    iban,
+                    owner,
+                },
+            },
+        };
+        if (this.options_.debugMode) {
+            try {
+                this.logger_.info(JSON.stringify(payload));
+            }
+            catch (e) { }
+        }
+        return payload;
+    }
+    /**
+     * Creates the direct debit mandate when the payload is passed from the order
+     * created hook. The returned data replaces the session data wholesale, so the
+     * payload key is always stripped, persisting it back would create a second
+     * mandate on a later update.
+     */
+    async updatePayment(input) {
+        const { payload, ...data } = (input.data ?? {});
+        if (!payload) {
+            return { data };
+        }
+        // A retried order created hook must not create a second mandate
+        if (data.code) {
+            this.logger_.info(`Pay. direct debit mandate ${data.code} already exists, skipping creation`);
+            return { data };
+        }
+        try {
+            const response = await this.client_.createDirectDebit(payload);
+            if (!response) {
+                // Test mode does not create a mandate, keep the existing session data
+                return { data };
+            }
+            this.logger_.info(`Pay. direct debit mandate ${response.code} created for reference ${payload.reference} with amount ${payload.amount.currency} ${payload.amount.value}`);
+            return { data: response };
+        }
+        catch (error) {
+            this.logger_.error(`Error creating Pay. direct debit: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Retrieves payment details. Payments that hold a Pay. order or transaction
+     * id (created through the order API, or refunded) resolve through the base
+     * implementation, mandate based payments resolve through the mandate code.
+     */
+    async retrievePayment(input) {
+        const data = (input.data ?? {});
+        if (data.id || data.orderId) {
+            return await super.retrievePayment({
+                ...input,
+                data: { ...data, id: data.id ?? data.orderId },
+            });
+        }
+        const mandateId = this.readMandateId(data);
+        if (!mandateId) {
+            return { data };
+        }
+        const info = await this.client_.getDirectDebitInfoByMandate(mandateId);
+        return { data: info };
+    }
+    /**
+     * A mandate based direct debit is revoked by deleting the mandate at Pay.,
+     * so a pending collection is never executed for a canceled payment. The
+     * order API abort only applies to payments that hold a Pay. order id.
+     */
+    async cancelPayment(input) {
+        const data = (input.data ?? {});
+        if (data.orderId) {
+            return await super.cancelPayment(input);
+        }
+        const mandateId = this.readMandateId(data);
+        if (!mandateId) {
+            // Nothing was created at Pay. (e.g. test mode), nothing to revoke
+            return { data };
+        }
+        try {
+            await this.client_.deleteDirectDebitMandate(mandateId);
+            this.logger_.info(`Pay. direct debit mandate ${mandateId} deleted, no further collections will be executed`);
+            return { data };
+        }
+        catch (error) {
+            this.logger_.error(`Error deleting Pay. direct debit mandate ${mandateId}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * A mandate based direct debit only counts as captured when Pay. reports the
+     * direct debit as collected. The state is always re-fetched from Pay., so a
+     * spoofed exchange cannot capture an uncollected payment.
+     */
+    async capturePayment(input) {
+        const data = (input.data ?? {});
+        if (data.orderId) {
+            return await super.capturePayment(input);
+        }
+        const mandateId = this.readMandateId(data);
+        if (!mandateId) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No mandate code found on the payment data");
+        }
+        const info = await this.client_.getDirectDebitInfoByMandate(mandateId);
+        const directDebit = info.directdebits[0];
+        if (directDebit?.status.code === constants_1.PayDirectDebitStatusCode.COLLECTED) {
+            return {
+                data: {
+                    ...data,
+                    orderId: directDebit.orderId,
+                    amount: directDebit.amount,
+                    status: directDebit.status,
+                    directdebits: info.directdebits,
+                },
+            };
+        }
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, "The payment could not be captured.");
+    }
+    /**
+     * Refunds go through the regular transaction refund endpoint, using the Pay.
+     * transaction id of the collection. That id lives on the collected direct
+     * debit, not necessarily on the stored payment data, so it is resolved from
+     * the mandate when missing.
+     */
+    async refundPayment(input) {
+        const data = (input.data ?? {});
+        let directDebit = data.directdebits?.[0];
+        let orderId = data.orderId ?? directDebit?.orderId;
+        if (!orderId) {
+            const mandateId = this.readMandateId(data);
+            if (mandateId) {
+                const info = await this.client_
+                    .getDirectDebitInfoByMandate(mandateId)
+                    .catch((error) => {
+                    this.logger_.warn(`Could not retrieve direct debit mandate ${mandateId}: ${error.message}`);
+                    return undefined;
+                });
+                directDebit = info?.directdebits[0];
+                orderId = directDebit?.orderId;
+            }
+        }
+        if (!orderId) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "No Pay. transaction found for this direct debit, cannot refund.");
+        }
+        return await super.refundPayment({
+            ...input,
+            data: {
+                ...data,
+                orderId,
+                amount: data.amount ?? directDebit?.amount,
+            },
+        });
+    }
+    readMandateId(data) {
+        const mandateId = data.code ?? data.directdebits?.[0]?.mandate.code;
+        return typeof mandateId === "string" && mandateId.trim()
+            ? mandateId.trim()
+            : undefined;
+    }
 }
 PayDirectDebitService.identifier = types_1.PaymentProviderKeys.DIRECTDEBIT;
 exports.default = PayDirectDebitService;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5LWRpcmVjdC1kZWJpdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvcGF5L3NlcnZpY2VzL3BheS1kaXJlY3QtZGViaXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxnRUFBc0M7QUFDdEMsb0NBQTREO0FBRTVELE1BQU0scUJBQXNCLFNBQVEsa0JBQU87SUFHekMsSUFBSSxvQkFBb0I7UUFDdEIsT0FBTztZQUNMLFFBQVEsRUFBRSxHQUFHO1lBQ2IsVUFBVSxFQUNSLElBQUksQ0FBQyxRQUFRLENBQUMsU0FBUztnQkFDdkIsYUFBYTtnQkFDYiwyQkFBbUIsQ0FBQyxXQUFXO2dCQUMvQixNQUFNO1NBQ1QsQ0FBQTtJQUNILENBQUM7O0FBWE0sZ0NBQVUsR0FBRywyQkFBbUIsQ0FBQyxXQUFXLENBQUE7QUFjckQsa0JBQWUscUJBQXFCLENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pay-direct-debit.js","sourceRoot":"","sources":["../../../../../../src/providers/pay/services/pay-direct-debit.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/providers/pay/types/order.d.ts

@@ -10,12 +10,13 @@ export type PinPaymentMethod = {
     terminalCode: string;
 };
 export type DirectDebitPaymentMethod = {
-    firstName: string | null;
-    lastName: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+    accountHolder?: string | null;
     email: string | null;
     city: string | null;
     iban: string | null;
-    bic: string | null;
+    bic?: string | null;
     permissionGiven?: boolean;
 };
 export type KlarnaPaymentMethod = {
@@ -70,87 +71,155 @@ export interface UpdateOrder {
     description?: string;
     reference?: string;
 }
-export interface DirectDebitInfoRequest {
-    mandateId: string;
-    referenceId?: string;
-}
 export interface DirectDebitInfoResponse {
-    request: {
-        result: "0" | "1";
-        errorId: string;
-        errorMessage: string;
-    };
-    result: {
-        mandate: Mandate;
-        directDebit: DirectDebit[];
-    };
+    total: number;
+    count: number;
+    pages: number;
+    directdebits: DirectDebit[];
+    _links?: Record<string, {
+        href: string;
+        rel?: string;
+        type?: string;
+    }>;
 }
-interface Mandate {
-    mandateId: string;
-    type: MandateType;
-    bankaccountNumber: string;
-    bankaccounOwner: string;
-    bankaccountBic: string;
-    amount: string;
+export interface DirectDebit {
+    id: string;
     description: string;
-    intervalValue: string;
-    intervalPeriod: string;
-    intervalQuantity: string;
-    state: MandateState;
-    ipAddress: string;
-    email: string;
-    promotorId: string;
-    tool: string;
-    info: string;
-    extra1: string;
-    extra2: string;
-    extra3: string;
-}
-interface DirectDebit {
-    referenceId: string;
-    bankaccountNumber: string;
-    bankaccountHolder: string;
-    bankaccountBic: string;
+    url: string;
+    processDate: string;
+    orderId: string;
     paymentSessionId: string;
-    amount: string;
-    description: string;
-    sendDate: string;
-    receiveDate: string;
-    statusCode: string;
-    statusName: string;
-    declineCode: string;
-    declineName: string;
-    declineDate: string;
+    type: "SINGLE" | "RECURRING" | "FLEXIBLE";
+    amount: {
+        value: number;
+        currency: string;
+    };
+    status: {
+        code: number;
+        action: string;
+        phase: string;
+    };
+    declined: boolean;
+    decline: {
+        code: string;
+        reason: string;
+        date: string;
+    } | null;
+    bankAccount: {
+        iban: string;
+        bic: string;
+        owner: string;
+    };
+    mandate: {
+        code: string;
+        description: string;
+        reference: string;
+    };
+    service: {
+        code: string;
+        name: string;
+    };
+    merchant: {
+        code: string;
+        name: string;
+        status: "ACTIVE" | "INACTIVE";
+        incorporationCountry: string;
+    };
+    stats: DirectDebitStats;
+    createdAt: string;
+    createdBy: string;
+    modifiedAt: string;
+    modifiedBy: string;
+    deletedAt: string | null;
+    deletedBy: string | null;
+}
+interface DirectDebitStats {
+    info?: string | null;
+    tool?: string | null;
+    object?: string | null;
+    extra1?: string | null;
+    extra2?: string | null;
+    extra3?: string | null;
+    domainId?: string | null;
 }
-type MandateType = "single" | "recurring";
-type MandateState = "first" | "active" | "last" | "single";
 export interface CreateDirectDebitRequest {
-    reference: string;
     serviceId: string;
-    amount: number;
-    bankaccountHolder: string;
-    bankaccountNumber: string;
-    processDate?: string;
+    reference: string;
     description?: string;
-    currency?: string;
+    processDate?: string;
     exchangeUrl?: string;
-    ipAddress?: string;
-    email?: string;
-    promotorId?: number;
-    tool?: string;
-    info?: string;
-    object?: string;
-    extra1?: string;
-    extra2?: string;
-    extra3?: string;
+    type?: "SINGLE" | "RECURRING" | "FLEXIBLE";
+    interval?: {
+        period?: "day" | "week" | "month" | "trimester" | "halfyear" | "year";
+        quantity?: number;
+        value?: number;
+    };
+    amount: {
+        value: number;
+        currency?: string;
+    };
+    customer: {
+        ipAddress?: string;
+        email: string;
+        bankAccount: {
+            iban: string;
+            bic?: string;
+            owner: string;
+        };
+    };
+    stats?: DirectDebitStats;
 }
 export interface CreateDirectDebitResponse {
-    request: {
-        result: "0" | "1";
-        errorId: string;
-        errorMessage: string;
+    code: string;
+    serviceId: string;
+    reference: string;
+    description: string;
+    processDate: string;
+    exchangeUrl: string | null;
+    type: "SINGLE" | "RECURRING" | "FLEXIBLE";
+    interval: {
+        value: number;
+        quantity: number;
+        period: string;
+    };
+    amount: {
+        value: number;
+        currency: string;
+    };
+    customer: {
+        email: string;
+        ipAddress: string;
+        bankAccount: {
+            iban: string;
+            bic: string;
+            owner: string;
+        };
     };
-    result: string;
+    service: {
+        code: string;
+        name: string;
+    };
+    merchant: {
+        code: string;
+        name: string;
+        status: string;
+        incorporationCountry: string;
+    };
+    stats: DirectDebitStats;
+    lastDirectDebitDate: string | null;
+    nextDirectDebitDate: string | null;
+    actualDirectDebitDate: string | null;
+    createdAt: string;
+    createdBy: string;
+    modifiedAt: string;
+    modifiedBy: string;
+    deletedAt: string | null;
+    deletedBy: string | null;
+    _links?: {
+        href: string;
+        rel: string;
+        type: string;
+    }[];
 }
 export interface OrderResponse extends PayErrorResponse {
     id: string;