@unchainedshop/plugins 4.7.2 → 4.8.1

package/lib/payment/payrexx/handler-fastify.js

@@ -0,0 +1,91 @@
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:payrexx:handler');
+export const payrexxHandler = async (request, reply) => {
+    const resolvedContext = request.unchainedContext;
+    const { modules, services } = resolvedContext;
+    const { transaction } = request.body;
+    if (!transaction) {
+        logger.info(`unhandled event type`, {
+            type: Object.keys(request.body).join(','),
+        });
+        reply.status(200);
+        return reply.send({
+            success: false,
+            ignored: true,
+            message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
+        });
+    }
+    if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
+        logger.info(`unhandled transaction state: ${transaction.status}`);
+        reply.status(200);
+        return reply.send({
+            success: false,
+            ignored: true,
+            message: `Unhandled transaction state: ${transaction.status}`,
+        });
+    }
+    logger.info(`Processing event`, {
+        transactionId: transaction.id,
+    });
+    try {
+        if (transaction.preAuthorizationId) {
+            const { referenceId: paymentProviderId, invoice } = transaction;
+            const userId = '';
+            logger.info(`register credentials for: ${userId}`);
+            await services.orders.registerPaymentCredentials(paymentProviderId, {
+                userId,
+                transactionContext: { gatewayId: invoice.paymentRequestId },
+            });
+            logger.info(`registration successful`, {
+                paymentProviderId,
+                userId,
+            });
+            reply.status(200);
+            return reply.send({
+                success: true,
+                paymentProviderId,
+                userId,
+            });
+        }
+        else {
+            const { referenceId: orderPaymentId, invoice } = transaction;
+            logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
+            const orderPayment = await modules.orders.payments.findOrderPayment({
+                orderPaymentId,
+            });
+            if (!orderPayment) {
+                throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
+            }
+            await modules.orders.payments.logEvent(orderPaymentId, {
+                transactionId: transaction.id,
+            });
+            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+                paymentContext: {
+                    gatewayId: invoice.paymentRequestId,
+                },
+            });
+            if (!order)
+                throw new Error(`Order with id ${orderPayment.orderId} not found`);
+            logger.info(`checkout successful`, {
+                orderPaymentId,
+                orderId: order._id,
+            });
+            reply.status(200);
+            return reply.send({
+                success: true,
+                orderId: order._id,
+            });
+        }
+    }
+    catch (error) {
+        logger.error(error, {
+            transactionId: transaction.id,
+        });
+        reply.status(500);
+        return reply.send({
+            success: false,
+            message: error.message,
+            name: error.name,
+        });
+    }
+};

package/lib/payment/payrexx/index.d.ts

@@ -1,4 +1 @@
-import type { IPlugin } from '@unchainedshop/core';
-export declare const PayrexxPlugin: IPlugin;
-export default PayrexxPlugin;
-export { Payrexx } from './adapter.ts';
+export {};

package/lib/payment/payrexx/index.js

@@ -1,23 +1,162 @@
-import { Payrexx } from "./adapter.js";
-import { payrexxWebhookHandler } from "./api.js";
-const { PAYREXX_WEBHOOK_PATH = '/payment/payrexx' } = process.env;
-export const PayrexxPlugin = {
+import { createLogger } from '@unchainedshop/logger';
+import { mapOrderDataToGatewayObject, mapUserToGatewayObject } from "./payrexx.js";
+import createPayrexxAPI, { GatewayObjectStatus } from "./api/index.js";
+import { OrderPricingSheet, PaymentAdapter, PaymentDirector, PaymentError, } from '@unchainedshop/core';
+const logger = createLogger('unchained:payrexx');
+const Payrexx = {
+    ...PaymentAdapter,
     key: 'shop.unchained.payment.payrexx',
-    label: 'Payrexx Payment Plugin',
+    label: 'Payrexx',
     version: '1.0.0',
-    adapters: [Payrexx],
-    routes: [
-        {
-            path: PAYREXX_WEBHOOK_PATH,
-            method: 'POST',
-            handler: payrexxWebhookHandler,
-        },
-    ],
-    onRegister: () => {
-        if (!process.env.PAYREXX_SECRET) {
-            throw new Error('PAYREXX_SECRET not set');
-        }
+    typeSupported(type) {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const { modules } = context;
+        const instance = config.find((c) => c.key === 'instance')?.value;
+        const adapterActions = {
+            ...PaymentAdapter.actions(config, context),
+            configurationError() {
+                if (!process.env.PAYREXX_SECRET) {
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                }
+                if (!instance) {
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                }
+                return null;
+            },
+            isActive: () => {
+                if (adapterActions.configurationError() === null)
+                    return true;
+                return false;
+            },
+            isPayLaterAllowed() {
+                return false;
+            },
+            sign: async (transactionContext = {}) => {
+                const { orderPayment, userId, order } = context;
+                if (!order)
+                    throw new Error('No order in context, can only sign with order context');
+                const api = createPayrexxAPI(instance, process.env.PAYREXX_SECRET);
+                if (orderPayment) {
+                    const pricing = OrderPricingSheet({
+                        calculation: order.calculation,
+                        currencyCode: order.currencyCode,
+                    });
+                    const gatewayObject = mapOrderDataToGatewayObject({ order, orderPayment, pricing }, transactionContext);
+                    const gateway = await api.createGateway(gatewayObject);
+                    return JSON.stringify(gateway);
+                }
+                const user = userId && (await modules.users.findUserById(userId));
+                if (!user)
+                    throw new Error('User not found, can only sign registrations with user context');
+                const emailAddress = modules.users.primaryEmail(user)?.address;
+                const gateway = await api.createGateway(mapUserToGatewayObject({
+                    userId,
+                    emailAddress,
+                    currencyCode: order?.currencyCode,
+                }));
+                return JSON.stringify(gateway);
+            },
+            async register() {
+                throw new Error('Not implemented');
+                return null;
+            },
+            async confirm() {
+                const { orderPayment } = context;
+                if (!orderPayment?.transactionId) {
+                    return false;
+                }
+                const { transactionId } = orderPayment;
+                const api = createPayrexxAPI(instance, process.env.PAYREXX_SECRET);
+                const gatewayObject = await api.getGateway(transactionId);
+                if (!gatewayObject) {
+                    return false;
+                }
+                if (gatewayObject.status === GatewayObjectStatus.reserved) {
+                    const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
+                    await Promise.all(allTransactions.map(async (transaction) => api.chargePreAuthorized(transaction.id, { referenceId: '__IGNORE_WEBHOOK__' })));
+                    return true;
+                }
+                if (gatewayObject.status === GatewayObjectStatus.confirmed) {
+                    return true;
+                }
+                return false;
+            },
+            async cancel() {
+                const { orderPayment } = context;
+                if (!orderPayment?.transactionId) {
+                    return false;
+                }
+                const { transactionId } = orderPayment;
+                const api = createPayrexxAPI(instance, process.env.PAYREXX_SECRET);
+                const gatewayObject = await api.getGateway(transactionId);
+                if (!gatewayObject) {
+                    return false;
+                }
+                if (gatewayObject.status === GatewayObjectStatus.reserved) {
+                    const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
+                    await Promise.all(allTransactions.map(async (transaction) => api.deleteReservation(transaction.id)));
+                    return true;
+                }
+                if (gatewayObject.status === GatewayObjectStatus.confirmed) {
+                    return false;
+                }
+                return true;
+            },
+            charge: async ({ gatewayId, paymentCredentials }) => {
+                if (!gatewayId && !paymentCredentials) {
+                    throw new Error('You have to provide gatewayId or paymentCredentials');
+                }
+                const { order, orderPayment } = context;
+                if (!order)
+                    throw new Error('No order in context, can only charge with order context');
+                if (!orderPayment)
+                    throw new Error('Order payment not found');
+                const api = createPayrexxAPI(instance, process.env.PAYREXX_SECRET);
+                const gatewayObject = await api.getGateway(gatewayId);
+                if (!gatewayObject) {
+                    throw new Error('Could not load gateway from the Payrexx API');
+                }
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const { currencyCode, amount } = pricing.total({ useNetPrice: false });
+                if (gatewayObject.status === 'reserved' ||
+                    gatewayObject.status === 'confirmed') {
+                    try {
+                        if (gatewayObject.currency !== currencyCode.toUpperCase() ||
+                            gatewayObject.amount !== Math.round(amount)) {
+                            throw new Error('The price has changed since the intent has been created');
+                        }
+                        if (gatewayObject.referenceId !== orderPayment?._id) {
+                            throw new Error('The order payment is different from the initiating intent');
+                        }
+                        logger.info(`Mark as charged, status is ${gatewayObject.status}`, {
+                            orderPaymentId: gatewayObject.referenceId,
+                        });
+                        return {
+                            transactionId: gatewayId,
+                            gatewayObject,
+                        };
+                    }
+                    catch (e) {
+                        if (gatewayObject.status === GatewayObjectStatus.reserved) {
+                            const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
+                            await Promise.all(allTransactions.map(async (transaction) => api.deleteReservation(transaction.id)));
+                        }
+                        throw e;
+                    }
+                }
+                logger.info('Charge not possible', {
+                    orderPaymentId: gatewayObject.referenceId,
+                    status: gatewayObject.status,
+                });
+                throw new Error(`Gateway Status ${gatewayObject.status} does not allow checkout`);
+            },
+        };
+        return adapterActions;
     },
 };
-export default PayrexxPlugin;
-export { Payrexx } from "./adapter.js";
+PaymentDirector.registerAdapter(Payrexx);

package/lib/payment/postfinance-checkout/handler-express.d.ts

@@ -0,0 +1 @@
+export declare const postfinanceCheckoutHandler: (req: any, res: any) => Promise<void>;

package/lib/payment/postfinance-checkout/handler-express.js

@@ -0,0 +1,37 @@
+import { createLogger } from '@unchainedshop/logger';
+import { getTransaction, getTransactionCompletion } from "./api.js";
+const logger = createLogger('unchained:postfinance-checkout:handler');
+export const postfinanceCheckoutHandler = async (req, res) => {
+    const context = req.unchainedContext;
+    const { services, modules } = context;
+    const data = req.body;
+    if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
+        try {
+            const transactionCompletion = await getTransactionCompletion(data.entityId);
+            const transaction = await getTransaction(transactionCompletion ? transactionCompletion.linkedTransaction : data.entityId);
+            const { orderPaymentId } = transaction.metaData;
+            const orderPayment = await modules.orders.payments.findOrderPayment({
+                orderPaymentId,
+            });
+            if (!orderPayment)
+                throw new Error('Order Payment not found');
+            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+                paymentContext: {
+                    transactionId: transactionCompletion.linkedTransaction,
+                },
+            });
+            if (!order)
+                throw new Error(`Order with id ${orderPayment.orderId} not found`);
+            logger.info(`Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData?.orderPaymentId} as paid`);
+            res.status(200).send(`Order marked as paid: ${order.orderNumber}`);
+        }
+        catch (e) {
+            logger.error(e);
+            res.status(500).send({ name: e.name, code: e.code, message: e.message });
+        }
+    }
+    else {
+        logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
+        res.status(404).end();
+    }
+};

package/lib/payment/postfinance-checkout/handler-fastify.d.ts

@@ -0,0 +1,2 @@
+import type { RouteHandlerMethod } from 'fastify';
+export declare const postfinanceCheckoutHandler: RouteHandlerMethod;

package/lib/payment/postfinance-checkout/handler-fastify.js

@@ -0,0 +1,40 @@
+import { createLogger } from '@unchainedshop/logger';
+import { getTransaction, getTransactionCompletion } from "./api.js";
+const logger = createLogger('unchained:postfinance-checkout:handler');
+export const postfinanceCheckoutHandler = async (req, reply) => {
+    const context = req.unchainedContext;
+    const { services, modules } = context;
+    const data = req.body;
+    if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
+        try {
+            const transactionCompletion = await getTransactionCompletion(data.entityId);
+            const transaction = await getTransaction(transactionCompletion ? transactionCompletion.linkedTransaction : data.entityId);
+            const { orderPaymentId } = transaction.metaData;
+            const orderPayment = await modules.orders.payments.findOrderPayment({
+                orderPaymentId,
+            });
+            if (!orderPayment)
+                throw new Error('Order Payment not found');
+            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+                paymentContext: {
+                    transactionId: transaction.id,
+                },
+            });
+            if (!order)
+                throw new Error(`Order with id ${orderPayment.orderId} not found`);
+            logger.info(`Transaction ${transaction.id} marked order payment ID ${transaction.metaData?.orderPaymentId} as paid`);
+            reply.status(200);
+            return reply.send({ success: true, orderNumber: order.orderNumber });
+        }
+        catch (e) {
+            logger.error(e);
+            reply.status(500);
+            return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
+        }
+    }
+    else {
+        logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
+        reply.status(404);
+        return reply.send();
+    }
+};

package/lib/payment/postfinance-checkout/index.d.ts

@@ -1,7 +1,2 @@
-import type { IPlugin } from '@unchainedshop/core';
-export declare const PostfinanceCheckoutPlugin: IPlugin;
-export default PostfinanceCheckoutPlugin;
-export { PostfinanceCheckout } from './adapter.ts';
 export * from './types.ts';
 export * from './api-types.ts';
-export * from './utils.ts';

package/lib/payment/postfinance-checkout/index.js

@@ -1,31 +1,192 @@
-import { PostfinanceCheckout } from "./adapter.js";
-import { postfinanceCheckoutWebhookHandler } from "./webhook.js";
-const { PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout' } = process.env;
-export const PostfinanceCheckoutPlugin = {
+import { createLogger } from '@unchainedshop/logger';
+import { OrderPricingSheet, PaymentAdapter, PaymentDirector, PaymentError, } from '@unchainedshop/core';
+import { confirmDeferredTransaction, createTransaction, getIframeJavascriptUrl, getLightboxJavascriptUrl, getPaymentPageUrl, getToken, getTransaction, refundTransaction, voidTransaction, } from "./api.js";
+import { orderIsPaid } from "./utils.js";
+import { CompletionModes, IntegrationModes } from "./types.js";
+import { LineItemType, TokenizationMode, TransactionCompletionBehavior, TransactionState, CreationEntityState, } from "./api-types.js";
+const { PFCHECKOUT_SPACE_ID, PFCHECKOUT_USER_ID, PFCHECKOUT_SECRET, PFCHECKOUT_SUCCESS_URL, PFCHECKOUT_FAILED_URL, } = process.env;
+const logger = createLogger('unchained:postfinance-checkout');
+const newError = ({ code, message }) => {
+    const error = new Error(message);
+    error.name = `POSTFINANCE_${code}`;
+    return error;
+};
+const PostfinanceCheckout = {
+    ...PaymentAdapter,
     key: 'shop.unchained.payment.postfinance-checkout',
-    label: 'Postfinance Checkout Payment Plugin',
+    label: 'Postfinance Checkout',
     version: '1.0.0',
-    adapters: [PostfinanceCheckout],
-    routes: [
-        {
-            path: PFCHECKOUT_WEBHOOK_PATH,
-            method: 'POST',
-            handler: postfinanceCheckoutWebhookHandler,
-        },
-    ],
-    onRegister: () => {
-        const { PFCHECKOUT_SPACE_ID, PFCHECKOUT_USER_ID, PFCHECKOUT_SECRET, PFCHECKOUT_SUCCESS_URL, PFCHECKOUT_FAILED_URL, } = process.env;
-        if (!PFCHECKOUT_SPACE_ID ||
-            !PFCHECKOUT_USER_ID ||
-            !PFCHECKOUT_SECRET ||
-            !PFCHECKOUT_SUCCESS_URL ||
-            !PFCHECKOUT_FAILED_URL) {
-            throw new Error('Postfinance Checkout environment variables not fully configured');
-        }
+    typeSupported(type) {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const adapter = {
+            ...PaymentAdapter.actions(config, context),
+            getCompletionMode() {
+                return (config.find((item) => item.key === 'completionMode')?.value ||
+                    CompletionModes.Deferred);
+            },
+            configurationError() {
+                if (!PFCHECKOUT_SPACE_ID ||
+                    !PFCHECKOUT_USER_ID ||
+                    !PFCHECKOUT_SECRET ||
+                    !PFCHECKOUT_SUCCESS_URL ||
+                    !PFCHECKOUT_FAILED_URL) {
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                }
+                return null;
+            },
+            isActive() {
+                if (adapter.configurationError() === null)
+                    return true;
+                return false;
+            },
+            isPayLaterAllowed() {
+                return false;
+            },
+            async validate(credentials) {
+                if (!credentials.meta)
+                    return false;
+                const { linkedSpaceId } = credentials.meta;
+                const tokenData = await getToken(linkedSpaceId, credentials.token);
+                return tokenData.state === CreationEntityState.ACTIVE;
+            },
+            sign: async (transactionContext = {}) => {
+                const { orderPayment, order } = context;
+                if (!order)
+                    throw new Error('No order in context, can only sign with order context');
+                if (!orderPayment)
+                    throw new Error('No order payment in context, can only sign with order payment context');
+                const { integrationMode = IntegrationModes.PaymentPage } = transactionContext;
+                const completionMode = adapter.getCompletionMode();
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const totalAmount = pricing?.total({ useNetPrice: false }).amount;
+                const transaction = {
+                    currency: order.currencyCode,
+                    metaData: {
+                        orderPaymentId: orderPayment._id,
+                    },
+                    successUrl: `${transactionContext?.successUrl || PFCHECKOUT_SUCCESS_URL}?order_id=${orderPayment.orderId}`,
+                    failedUrl: `${transactionContext?.failedUrl || PFCHECKOUT_FAILED_URL}?order_id=${orderPayment.orderId}`,
+                    customerId: order?.userId || context?.userId,
+                    tokenizationMode: TokenizationMode.ALLOW_ONE_CLICK_PAYMENT,
+                };
+                if (completionMode === CompletionModes.Immediate) {
+                    transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_IMMEDIATELY;
+                }
+                else if (completionMode === CompletionModes.Deferred) {
+                    transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_DEFERRED;
+                }
+                if (totalAmount) {
+                    const lineItemSum = {
+                        name: `Bestellung ${orderPayment.orderId}`,
+                        type: LineItemType.FEE,
+                        quantity: 1,
+                        uniqueId: orderPayment.orderId,
+                        amountIncludingTax: totalAmount / 100,
+                    };
+                    transaction.lineItems = [lineItemSum];
+                }
+                const transactionId = await createTransaction(transaction);
+                if (!transactionId)
+                    throw new Error('Could not create transaction');
+                let location = null;
+                if (integrationMode === IntegrationModes.PaymentPage) {
+                    location = await getPaymentPageUrl(transactionId);
+                }
+                else if (integrationMode === IntegrationModes.Lightbox) {
+                    location = await getLightboxJavascriptUrl(transactionId);
+                }
+                else if (integrationMode === IntegrationModes.iFrame) {
+                    location = await getIframeJavascriptUrl(transactionId);
+                }
+                const res = {
+                    transactionId,
+                    location,
+                };
+                return JSON.stringify(res);
+            },
+            charge: async ({ transactionId, paymentCredentials, }) => {
+                if (paymentCredentials && !transactionId) {
+                    throw new Error('Not implemented yet');
+                }
+                if (!transactionId)
+                    return false;
+                const transaction = await getTransaction(transactionId);
+                if (!transaction) {
+                    logger.error(`Transaction #${transactionId}: Transaction not found`);
+                    throw newError({
+                        code: `TRANSACTION_NOT_FOUND`,
+                        message: 'Payment declined',
+                    });
+                }
+                const { order, orderPayment } = context;
+                if (!orderPayment)
+                    throw new Error('No order payment in context, cannot charge payment');
+                if (!order)
+                    throw new Error('No order in context, can only sign with order context');
+                const isPaid = await orderIsPaid(order, transaction);
+                if (!isPaid) {
+                    logger.error(`Transaction #${transactionId}: Invalid state / Amount incorrect`);
+                    throw newError({
+                        code: `STATE_${transaction.state?.toUpperCase()}`,
+                        message: 'Invalid state / Amount incorrect',
+                    });
+                }
+                if (transaction.metaData?.orderPaymentId !== orderPayment._id) {
+                    logger.error(`Transaction #${transactionId}: Invalid state / Amount incorrect`);
+                    throw newError({
+                        code: `TRANSACTION_ALREADY_USED`,
+                        message: 'Transaction already used in previous checkout',
+                    });
+                }
+                const { id, ...tokenMeta } = transaction.token || {};
+                return {
+                    transaction,
+                    transactionId,
+                    credentials: id && {
+                        ...tokenMeta,
+                        token: id.toString(),
+                    },
+                };
+            },
+            cancel: async () => {
+                const { orderPayment, order } = context;
+                if (!order)
+                    throw new Error('No order in context, can only cancel with order context');
+                if (!orderPayment?.transactionId) {
+                    return false;
+                }
+                const { transactionId } = orderPayment;
+                const transaction = await getTransaction(transactionId);
+                const refund = transaction.state === TransactionState.FULFILL;
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const totalAmount = pricing?.total({ useNetPrice: false }).amount;
+                return ((refund && refundTransaction(transactionId, order._id, totalAmount / 100)) ||
+                    voidTransaction(transactionId));
+            },
+            confirm: async () => {
+                const { orderPayment } = context;
+                if (!orderPayment?.transactionId) {
+                    return false;
+                }
+                const { transactionId } = orderPayment;
+                const transaction = await getTransaction(transactionId);
+                if (transaction.state === TransactionState.AUTHORIZED) {
+                    return confirmDeferredTransaction(transactionId);
+                }
+                return false;
+            },
+        };
+        return adapter;
     },
 };
-export default PostfinanceCheckoutPlugin;
-export { PostfinanceCheckout } from "./adapter.js";
+PaymentDirector.registerAdapter(PostfinanceCheckout);
 export * from "./types.js";
 export * from "./api-types.js";
-export * from "./utils.js";

package/lib/payment/saferpay/adapter.js

@@ -1,7 +1,7 @@
 import { mongodb } from '@unchainedshop/mongodb';
 import { SaferpayClient } from "./api/index.js";
 import { buildSignature } from "./buildSignature.js";
-import { OrderPricingSheet, PaymentAdapter, PaymentError, } from '@unchainedshop/core';
+import { OrderPricingSheet, PaymentAdapter, PaymentDirector, PaymentError, } from '@unchainedshop/core';
 const newSaferpayError = ({ code, message }) => {
     const error = new Error(message || code);
     error.name = `SAFERPAY_${code}`;
@@ -187,3 +187,4 @@ export const WordlineSaferpay = {
         return adapter;
     },
 };
+PaymentDirector.registerAdapter(WordlineSaferpay);

package/lib/payment/saferpay/handler-express.d.ts

@@ -0,0 +1 @@
+export declare const saferpayHandler: (request: any, response: any) => Promise<void>;