@monkeyplus/payscope 1.0.0

package/dist/_chunks/lib.mjs

@@ -0,0 +1,3073 @@
+import { checkouts, refunds, sessions, transactions } from "./database.mjs";
+import { eq } from "drizzle-orm";
+import { ofetch } from "ofetch";
+import dayjs from "dayjs";
+import { createError } from "h3";
+import { Buffer } from "node:buffer";
+import crypto from "node:crypto";
+import qs from "qs";
+import { joinURL } from "ufo";
+function roundNum(v, r = 2) {
+	return Number(Number(v).toFixed(r));
+}
+function calcPercentaje(value, percentaje, hasInclude) {
+	const val = +value;
+	const per = +percentaje;
+	if (hasInclude) return roundNum(val * per / (100 + per));
+	else return roundNum(val / 100 * per);
+}
+function calcDiscount(amount, discount) {
+	if ("percent" in discount) return {
+		amount: calcPercentaje(amount, discount.percent),
+		percent: +discount.percent
+	};
+	else return { amount: +discount.amount };
+}
+const sum = (arr) => arr.reduce((a, b) => a + b, 0);
+const flatten = (arr) => arr.reduce((a, b) => a.concat(b), []);
+function groupBy(fn, arr) {
+	return arr.reduce((acc, value) => {
+		const key = fn(value);
+		if (!acc[key]) acc[key] = [];
+		acc[key].push(value);
+		return acc;
+	}, {});
+}
+function calcAmount(_itemDiscount, _parentDiscount, taxIncluded) {
+	return (price) => {
+		if (!taxIncluded) {
+			const itemDiscount = calcDiscount(price, _itemDiscount);
+			const parentDiscount = calcDiscount(price - itemDiscount.amount, _parentDiscount);
+			const unitBase = price - (itemDiscount.amount + parentDiscount.amount);
+			return {
+				price,
+				discounts: {
+					itemDiscount,
+					parentDiscount
+				},
+				unitAmount: unitBase,
+				unitBase
+			};
+		} else {
+			const parentDiscount = calcDiscount(price, _parentDiscount);
+			const itemDiscount = calcDiscount(price - parentDiscount.amount, _itemDiscount);
+			return {
+				price,
+				discounts: {
+					itemDiscount,
+					parentDiscount
+				},
+				unitAmount: price - (itemDiscount.amount + parentDiscount.amount),
+				unitBase: 0
+			};
+		}
+	};
+}
+function calcTax(unitBase, quantity, taxtIncluded = false) {
+	return (tax) => {
+		const amount = calcPercentaje(unitBase, tax.value, taxtIncluded);
+		const base = taxtIncluded ? unitBase - amount : unitBase;
+		return {
+			amount,
+			totalAmount: amount * quantity,
+			base,
+			totalBase: base * quantity,
+			...tax
+		};
+	};
+}
+function calcSingleItem(parentDiscount) {
+	return (item) => {
+		const firstTaxes = item.taxes.filter((tax) => tax.beforeTaxes === true);
+		const latestTaxes = item.taxes.filter((tax) => !tax.beforeTaxes);
+		const quantity = +item.quantity;
+		if (!item.taxIncluded) {
+			const amounts = calcAmount(item.discount, parentDiscount)(+item.price);
+			const _firstTaxes = firstTaxes.map((i) => calcTax(i.excludeDiscount ? amounts.price : amounts.unitBase, quantity)(i));
+			const firstTotalTaxes = sum(_firstTaxes.map((v) => v.amount));
+			const base2 = amounts.unitBase + firstTotalTaxes;
+			const _latestTaxes = latestTaxes.map(calcTax(base2, quantity));
+			return {
+				id: item.id,
+				title: item.title,
+				taxIncluded: item.taxIncluded,
+				item: amounts,
+				taxes: [..._firstTaxes, ..._latestTaxes],
+				quantity: +item.quantity,
+				product: item.product,
+				variant: item.variant,
+				discountAllocations: item.discountAllocations
+			};
+		} else {
+			const amounts = calcAmount(item.discount, parentDiscount, true)(+item.price);
+			const UNIT_AMOUNT = +amounts.unitAmount;
+			const _latestTaxes = latestTaxes.map(calcTax(UNIT_AMOUNT, quantity, item.taxIncluded));
+			const latestTotalTaxes = sum(_latestTaxes.map((tax) => tax.amount));
+			const unitTaxBase = +UNIT_AMOUNT - latestTotalTaxes;
+			const _firstTaxes = firstTaxes.map(calcTax(unitTaxBase, quantity, item.taxIncluded));
+			const UNIT_BASE = unitTaxBase - sum(_firstTaxes.map((tax) => tax.amount));
+			const taxes = [..._firstTaxes, ..._latestTaxes];
+			amounts.unitBase = UNIT_BASE;
+			amounts.total = amounts.unitBase * quantity + taxes.reduce((acc, tax) => acc + tax.totalAmount, 0);
+			return {
+				id: item.id,
+				title: item.title,
+				taxIncluded: item.taxIncluded,
+				item: amounts,
+				quantity: +item.quantity,
+				taxes,
+				product: item.product,
+				variant: item.variant,
+				discountAllocations: item.discountAllocations
+			};
+		}
+	};
+}
+function calcItems(items, parentDiscount = { amount: 0 }) {
+	return items.map(calcSingleItem(parentDiscount));
+}
+function buildInvoice(items) {
+	const base = sum(items.map((item) => item.item.unitBase * item.quantity));
+	const lineItemsSubtotalPrice = sum(items.filter((item) => !["_envio"].includes(item.id)).map((item) => item.item.price * item.quantity));
+	const shipping = sum(items.filter((item) => ["_envio"].includes(item.id)).map((item) => item.item.price * item.quantity));
+	const imp = groupBy((tax) => {
+		return `${tax.type.code}_${tax.code}`;
+	}, flatten(items.map((item) => item.taxes)));
+	const _taxes = Object.values(imp).map((taxes) => {
+		let base = 0;
+		let value = 0;
+		const type = taxes[0].type.code;
+		const title = taxes[0].type.name;
+		const code = taxes[0].code;
+		const rate = +taxes[0].value;
+		for (const iterator of taxes) {
+			base += +iterator.totalBase;
+			value += +iterator.totalAmount;
+		}
+		return {
+			type,
+			code,
+			base,
+			value,
+			rate,
+			title
+		};
+	});
+	return {
+		total: base + sum(_taxes.map((tax) => tax.value)),
+		totalTax: sum(_taxes.map((t) => t.value)),
+		base,
+		items,
+		taxes: _taxes,
+		lineItemsSubtotalPrice,
+		shipping
+	};
+}
+function omit(keys, obj = {}) {
+	const result = {};
+	for (const key in obj) if (!keys.includes(key)) result[key] = obj[key];
+	return result;
+}
+function createCheckout({ graphql }) {
+	return async (_items, opts) => {
+		const { shipping: totalShipping, ...inv } = buildInvoice(calcItems(_items));
+		const _checkout = {
+			...omit(["lineItemsSubtotalPrice"], inv),
+			...opts,
+			totalShipping
+		};
+		return await graphql.checkout.create(_checkout);
+	};
+}
+function readCheckout({ graphql }) {
+	return async (id) => {
+		return await graphql.checkout.findByPk(id);
+	};
+}
+function associateCheckout({ graphql }) {
+	return async (id, sessionId, data) => {
+		return await graphql.checkout.updateByPk(id, {
+			...data,
+			sessionId
+		});
+	};
+}
+function useCheckout({ graphql }) {
+	return {
+		create: createCheckout({ graphql }),
+		read: readCheckout({ graphql }),
+		associate: associateCheckout({ graphql })
+	};
+}
+var CustomError = class CustomError extends Error {
+	httpStatusCode;
+	date;
+	constructor({ message, statusCode = 500 }) {
+		super(message);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, CustomError);
+		this.name = "CustomError";
+		this.httpStatusCode = statusCode;
+		this.date = /* @__PURE__ */ new Date();
+	}
+};
+function assertTransactionProvider(provider, transactionProvider) {
+	if (provider !== transactionProvider) throw new CustomError({
+		message: `Provider ${provider} does not match transaction provider ${transactionProvider}`,
+		statusCode: 400
+	});
+}
+function postPreparePayment({ transaction, providers, tasks }) {
+	return async (provider, body, options) => {
+		const _provider = providers[provider];
+		if (!_provider) throw new CustomError({
+			message: `Provider ${provider} dont exist`,
+			statusCode: 400
+		});
+		const _transaction = await transaction.read(body.transactionId);
+		assertTransactionProvider(provider, _transaction.provider);
+		if (!_provider.postPrepare) throw new CustomError({
+			message: `Postprocess ${provider} dont exist`,
+			statusCode: 400
+		});
+		const r = await _provider.postPrepare(_transaction.id, _transaction, {
+			...options,
+			body
+		});
+		await transaction.updateState({
+			id: _transaction.id,
+			details: {},
+			extras: {
+				..._transaction.extras,
+				...r.extras
+			},
+			status: "created",
+			ref: `${r.id}`
+		}).catch((e) => {
+			console.error("Error updating transaction state:", e);
+			throw e;
+		});
+		return {
+			...r,
+			uid: _transaction.id
+		};
+	};
+}
+function preparePayment({ transaction, providers, tasks }) {
+	return async (provider, body, options) => {
+		const _provider = providers[provider];
+		if (!_provider) throw new CustomError({
+			message: `Provider ${provider} dont exist`,
+			statusCode: 400
+		});
+		const _transaction = await transaction.create({
+			...body,
+			provider
+		});
+		const r = await _provider.prepare(_transaction.id, _transaction, options);
+		await transaction.updateState({
+			id: _transaction.id,
+			details: {},
+			extras: r.extras || void 0,
+			status: "created",
+			ref: `${r.id}`
+		});
+		await tasks.addJob("updateStatus", {
+			id: _transaction.id,
+			payload: { status: "created" },
+			sonda: r.sonda ? {
+				uid: _transaction.id,
+				verify: _transaction.endpoints.verify,
+				expiredAt: typeof r.sonda === "number" ? r.sonda : void 0
+			} : void 0
+		}, { queueName: `t-${_transaction.id}` }).catch((error) => {
+			console.warn("Could not enqueue updateStatus on prepare:", error);
+		});
+		return {
+			...r,
+			uid: _transaction.id
+		};
+	};
+}
+function payPayment({ providers, transaction, tasks }) {
+	return async (provider, params) => {
+		const _provider = providers[provider];
+		if (!_provider) throw new CustomError({
+			message: `Provider ${provider} dont exist`,
+			statusCode: 400
+		});
+		const _transaction = await transaction.read(params.uid);
+		assertTransactionProvider(provider, _transaction.provider);
+		if (_transaction.status !== "created") return {
+			id: _transaction.ref || "",
+			uid: _transaction.id,
+			status: _transaction.status,
+			body: _transaction.details,
+			message: {
+				failure: "Transacción rechazada",
+				pending: "Transacción pendiente",
+				refund: "Transacción reembolsada",
+				success: "Transacción aprobada"
+			}[_transaction.status] || "Transacción iniciada"
+		};
+		await transaction.updateState({
+			id: params.uid,
+			status: "pending",
+			details: {}
+		});
+		const state = await _provider.sendPay(params, {
+			uid: params.uid,
+			transaction: _transaction,
+			tasks
+		});
+		await tasks.addJob("updateStatus", {
+			id: params.uid,
+			payload: {
+				status: state.status,
+				details: state.body,
+				ref: state.id
+			},
+			sonda: state.sonda ? {
+				uid: params.uid,
+				verify: _transaction.endpoints.verify,
+				expiredAt: typeof state.sonda === "number" ? state.sonda : void 0
+			} : void 0
+		}, { queueName: `t-${params.uid}` }).catch(async (error) => {
+			console.warn("Could not enqueue updateStatus after pay, writing fallback state:", error);
+			await transaction.updateState({
+				id: params.uid,
+				status: state.status,
+				details: state.body,
+				ref: state.id
+			}).catch((fallbackError) => {
+				console.error("Could not write fallback state after pay:", fallbackError);
+			});
+		});
+		return state;
+	};
+}
+function verifyPayment({ providers, transaction }) {
+	return async (provider, uid, override) => {
+		const _provider = providers[provider];
+		if (!_provider) throw new CustomError({
+			message: `Provider ${provider} dont exist`,
+			statusCode: 400
+		});
+		const _transaction = await transaction.read(uid);
+		assertTransactionProvider(provider, _transaction.provider);
+		const totalTax = _transaction?.checkout?.taxes?.reduce((acc, tax) => acc + tax.value, 0);
+		const state = await _provider.verify({
+			uid,
+			transaction: _transaction,
+			override
+		});
+		return {
+			...state,
+			transaction: {
+				...state.transaction,
+				total: _transaction?.checkout?.total,
+				totalTax,
+				shipping: _transaction?.checkout?.shippingType?.price,
+				discount: _transaction?.checkout.discount,
+				items: _transaction?.checkout?.items?.map((item) => ({
+					item_id: item.id,
+					item_name: item.title,
+					price: item.variant?.price,
+					quantity: item.quantity
+				})).filter((el) => !el.item_id.startsWith("_"))
+			}
+		};
+	};
+}
+function webhookPayment({ providers, transaction, tasks }) {
+	return async (provider, uid, body) => {
+		const _provider = providers[provider];
+		if (!_provider) throw new CustomError({
+			message: `Provider ${provider} dont exist`,
+			statusCode: 400
+		});
+		const _transaction = await transaction.read(uid);
+		const state = await _provider.webhook(body, {});
+		if (state && state.status) await tasks.addJob("updateStatus", {
+			id: _transaction.id,
+			payload: { status: state?.status || "pending" },
+			sonda: void 0
+		}, { queueName: `t-${_transaction.id}` });
+		return {
+			message: state ? "Webhook approved" : "Webhook not approved",
+			body,
+			id: _transaction.ref || "",
+			uid,
+			status: state?.status
+		};
+	};
+}
+function refundPayment({ providers, transaction }) {
+	return async (provider, uid, options) => {
+		const _provider = providers[provider];
+		if (!_provider) throw new CustomError({
+			message: `Provider ${provider} dont exist`,
+			statusCode: 400
+		});
+		const _transaction = await transaction.read(uid);
+		assertTransactionProvider(provider, _transaction.provider);
+		if (_transaction.ref && !_transaction.refunds.totalCount) {
+			const totalAmount = Number(_transaction.checkout.total || 0);
+			const requestedAmount = Number(options?.amount || 0);
+			const refundAmount = requestedAmount > 0 && requestedAmount < totalAmount ? requestedAmount : totalAmount;
+			const details = await _provider.refund(_transaction.ref, refundAmount, options);
+			await transaction.refund({
+				id: uid,
+				details
+			});
+			await transaction.updateState({
+				id: uid,
+				status: "refund",
+				details: void 0
+			}).catch((e) => {
+				console.warn("Error updating transaction state:", e);
+			});
+			return {
+				message: "Refund aproved",
+				payload: details
+			};
+		} else {
+			if (_transaction.refunds.totalCount) return { message: "Esta transacción ya fue reversada" };
+			return { message: " Esta transacción no tiene ref" };
+		}
+	};
+}
+function usePayment(ctx) {
+	return {
+		pay: payPayment(ctx),
+		prepare: preparePayment(ctx),
+		verify: verifyPayment(ctx),
+		refund: refundPayment(ctx),
+		postPrepare: postPreparePayment(ctx),
+		webhook: webhookPayment(ctx)
+	};
+}
+function createSession$1({ secret, graphql, storeId }) {
+	return async (opts) => {
+		const _session = {
+			hash: opts.hash || `${secret}${storeId}${opts.email}`,
+			email: opts.email,
+			storeId,
+			identification: opts.identification,
+			customer: opts.customer
+		};
+		return await graphql.session.create(_session);
+	};
+}
+function verifySession(secret, storeId) {
+	return async (opts, hash) => {
+		return true;
+	};
+}
+function useSession({ graphql, secret, storeId }) {
+	return {
+		create: createSession$1({
+			secret,
+			graphql,
+			storeId
+		}),
+		verify: verifySession(secret, storeId)
+	};
+}
+function createTransaction({ graphql, storeId }) {
+	return async (payload) => {
+		return await graphql.transaction.create({
+			...payload,
+			storeId
+		});
+	};
+}
+function readTransaction({ graphql }) {
+	return async (id) => {
+		return await graphql.transaction.findByPk(id);
+	};
+}
+function updateStateTransaction({ graphql }) {
+	return async ({ id, status, details, ref, extras }) => {
+		return await graphql.transaction.updateByPk(id, {
+			status,
+			details,
+			ref,
+			extras
+		});
+	};
+}
+function refundTransaction({ graphql }) {
+	return async ({ id, details }) => {
+		return await graphql.refunds.create({
+			transactionId: id,
+			details
+		});
+	};
+}
+function useTransaction({ graphql, storeId }) {
+	return {
+		create: createTransaction({
+			graphql,
+			storeId
+		}),
+		read: readTransaction({ graphql }),
+		updateState: updateStateTransaction({ graphql }),
+		refund: refundTransaction({ graphql })
+	};
+}
+function useTasks({ endpoint, headers }) {
+	const addJob = async (identifier, payload, spec) => {
+		await ofetch(endpoint, {
+			method: "POST",
+			body: {
+				task: identifier,
+				payload,
+				spec
+			},
+			headers
+		});
+	};
+	return { addJob };
+}
+const createPayment = (opts) => {
+	const graphql = opts.graphql;
+	const checkout = useCheckout({ graphql });
+	const session = useSession({
+		graphql,
+		secret: opts.secret,
+		storeId: opts.storeId
+	});
+	const transaction = useTransaction({
+		graphql,
+		storeId: opts.storeId
+	});
+	const tasks = useTasks({
+		endpoint: opts.tasks.url,
+		headers: opts.tasks.headers
+	});
+	const payment = usePayment({
+		transaction,
+		providers: opts.providers,
+		tasks
+	});
+	const getStore = async () => {
+		return graphql.stores.findByPk(opts.storeId);
+	};
+	return {
+		session,
+		checkout,
+		payment,
+		transaction,
+		providers: Object.keys(opts.providers),
+		_providers: opts.providers,
+		$graphql: graphql,
+		$tasks: tasks,
+		getStore
+	};
+};
+const codes$6 = {
+	0: {
+		status: "pending",
+		messages: { es: "Orden de pago creada" }
+	},
+	1: {
+		status: "success",
+		messages: { es: "Pago aprobado" }
+	},
+	9: {
+		status: "refund",
+		messages: { es: "Pago anulado" }
+	}
+};
+function normalizeStatus$4(data) {
+	const code = codes$6[data.statusQrCode];
+	if (!code) return {
+		status: "pending",
+		code: String(data.statusQrCode || "??"),
+		description: data?.message || "unknow code",
+		messages: { es: "Codigo desconocido" }
+	};
+	return {
+		...code,
+		description: data.message,
+		code: String(data.statusQrCode)
+	};
+}
+function verifyError$1(body) {
+	if (body.responseCode !== 0) throw createError({
+		cause: body.message,
+		message: body.message,
+		data: { ...body }
+	});
+}
+const createBancoEconomico = ({ endpoint, credentials, ...globalOptions }) => {
+	const api = ofetch.create({ baseURL: endpoint });
+	const encryt = async (text) => {
+		return await api("/api/authentication/encrypt", {
+			method: "GET",
+			params: {
+				text,
+				aesKey: globalOptions.aesKey
+			}
+		}).catch((e) => {
+			console.error("Error en encriptación:", e.response);
+			throw e;
+		});
+	};
+	const getAuth = async () => {
+		const password = await encryt(credentials.password);
+		const auth = await api("/api/authentication/authenticate", {
+			method: "POST",
+			body: {
+				userName: credentials.userName,
+				password
+			}
+		}).catch((e) => {
+			console.error("Error en encriptación:", e.response);
+			throw e;
+		});
+		verifyError$1(auth);
+		return auth;
+	};
+	return {
+		methods: {},
+		prepare: async (uid, transaction) => {
+			const { token } = await getAuth();
+			if (!token) throw new Error("No se pudo obtener el token de autenticación");
+			const accountCredit = await encryt(globalOptions.accountCredit);
+			const r = await api("/api/qrsimple/generateQR", {
+				method: "POST",
+				body: {
+					transactionId: transaction.id,
+					accountCredit,
+					currency: "BOB",
+					description: transaction.description || "Generacion de QR-Ecommerce",
+					amount: Number(transaction.checkout.total).toFixed(2),
+					dueDate: dayjs().add(1, "day").format("YYYY-MM-DD"),
+					singleUse: true,
+					modifyAmount: false,
+					branchCode: globalOptions.branchCode || "E0001"
+				},
+				headers: { Authorization: `Bearer ${token}` }
+			}).catch((e) => {
+				console.error("Error al crear el QR:", e);
+				throw e;
+			});
+			verifyError$1(r);
+			return {
+				id: r.qrId,
+				checkout: transaction.checkout,
+				...r,
+				sonda: dayjs().add(1, "day").valueOf()
+			};
+		},
+		sendPay: async ({ uid }, { transaction }) => {
+			const { token } = await getAuth();
+			const r = await api(`/api/qrsimple/v2/statusQr/${transaction.ref}`, {
+				method: "GET",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+			verifyError$1(r);
+			const details = normalizeStatus$4(r);
+			return {
+				id: transaction.ref,
+				uid,
+				status: details.status,
+				body: r,
+				message: details.description || details.messages?.es || "",
+				sonda: details.status !== "success" ? dayjs().add(28, "hours").valueOf() : false
+			};
+		},
+		verify: async ({ transaction }) => {
+			const { token } = await getAuth();
+			const r = await api(`/api/qrsimple/v2/statusQr/${transaction.ref}`, {
+				method: "GET",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+			verifyError$1(r);
+			const details = normalizeStatus$4(r);
+			return {
+				id: transaction.ref,
+				status: details.status,
+				responseRaw: r,
+				details,
+				customer: transaction.session.customer || {},
+				payments: {
+					current: {},
+					history: []
+				},
+				uid: transaction.id,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status,
+					responseTasks: transaction.responseTasks,
+					payloadTasks: { success: transaction.tasks.success?.map((el) => {
+						return el.payload;
+					}) }
+				}
+			};
+		},
+		refund: async () => {
+			return {};
+		}
+	};
+};
+const codes$5 = {
+	1: {
+		status: "pending",
+		messages: { es: "Orden de pago creada" }
+	},
+	2: {
+		status: "success",
+		messages: { es: "Pago aprobad" }
+	},
+	3: {
+		status: "refund",
+		messages: { es: "Pago anulado" }
+	}
+};
+function normalizeStatus$3(data) {
+	const code = codes$5[data.orderState];
+	if (!code) return {
+		status: "pending",
+		code: data.result || "??",
+		description: data?.message || "unknow code",
+		messages: { es: "Codigo desconocido" }
+	};
+	return {
+		...code,
+		description: data.message,
+		code: data.result
+	};
+}
+function verifyError(body) {
+	if (body.result !== "COD000") throw createError({
+		cause: body.message,
+		message: body.message,
+		data: { ...body }
+	});
+}
+const createBancoGanadero = ({ endpoint, apiKey, credentials }) => {
+	const api = ofetch.create({ baseURL: endpoint });
+	const getAuth = async () => {
+		const auth = await api("/ws-servicio-codigo-qr-empresas/enterprise/service/v1/qrcode/access", {
+			method: "POST",
+			body: credentials,
+			headers: { "x-api-key": apiKey }
+		});
+		verifyError(auth);
+		return auth;
+	};
+	return {
+		methods: {
+			login: async (body) => {
+				return {
+					result: "",
+					message: "",
+					token: ""
+				};
+			},
+			payments: async (body) => {
+				return {
+					result: "",
+					message: ""
+				};
+			}
+		},
+		prepare: async (uid, transaction) => {
+			const { token } = await getAuth();
+			if (!token) throw new Error("No se pudo obtener el token de autenticación");
+			const r = await api("/ws-servicio-codigo-qr-empresas/service/v1/qrcode/collections", {
+				method: "POST",
+				body: {
+					accountReference: "CUENTA_QR_BOB",
+					amount: transaction.checkout.total,
+					apiKey,
+					currency: "BOB",
+					userName: credentials.userName,
+					expirationDate: dayjs().add(1, "day").format("DDMMYYYY"),
+					reference: transaction.id,
+					transactionId: transaction.id,
+					singleUse: 1
+				},
+				headers: { Authorization: `Bearer ${token}` }
+			}).catch((e) => {
+				console.error("Error al crear el QR:", e);
+				throw e;
+			});
+			verifyError(r);
+			return {
+				id: r.qrId,
+				checkout: transaction.checkout,
+				...r,
+				sonda: dayjs().add(1, "day").valueOf()
+			};
+		},
+		sendPay: async ({ uid }, { transaction }) => {
+			const { token } = await getAuth();
+			const r = await api("/ws-servicio-codigo-qr-empresas/service/v1/qrcode/status", {
+				body: {
+					qrId: transaction.ref,
+					userName: credentials.userName,
+					apiKey
+				},
+				method: "POST",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+			verifyError(r);
+			const details = normalizeStatus$3(r);
+			return {
+				id: transaction.ref,
+				uid,
+				status: details.status,
+				body: r,
+				message: details.description || details.messages?.es || "",
+				sonda: details.status !== "success" ? dayjs().add(1, "day").valueOf() : false
+			};
+		},
+		verify: async ({ transaction }) => {
+			const { token } = await getAuth();
+			const r = await api("/ws-servicio-codigo-qr-empresas/service/v1/qrcode/status", {
+				body: {
+					qrId: transaction.ref,
+					userName: credentials.userName,
+					apiKey
+				},
+				method: "POST",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+			verifyError(r);
+			const details = normalizeStatus$3(r);
+			return {
+				id: transaction.ref,
+				status: details.status,
+				responseRaw: r,
+				details,
+				customer: transaction.session.customer || {},
+				payments: {
+					current: {},
+					history: []
+				},
+				uid: transaction.id,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status,
+					responseTasks: transaction.responseTasks,
+					payloadTasks: { success: transaction.tasks.success?.map((el) => {
+						return el.payload;
+					}) }
+				}
+			};
+		},
+		refund: async () => {
+			return {};
+		}
+	};
+};
+function computeHttpSignature(config, headerHash) {
+	let sig = "keyid=\"${keyid}\", algorithm=\"${algorithm}\", headers=\"${headers}\", signature=\"${signature}\"";
+	let signingBase = "";
+	config.headers.forEach((h) => {
+		if (signingBase !== "") signingBase += "\n";
+		signingBase += `${h.toLowerCase()}: ${headerHash[h]}`;
+	});
+	let hash;
+	const secret = Buffer.from(config.secretkey, "base64");
+	if (config.algorithm === "HmacSHA256" || config.algorithm === "SHA256withRSA") hash = crypto.createHmac("sha256", secret).update(signingBase).digest();
+	else throw new Error(`Unsupported algorithm: ${config.algorithm}`);
+	const signatureOptions = {
+		keyid: config.keyid,
+		algorithm: config.algorithm,
+		headers: config.headers,
+		signature: hash.toString("base64")
+	};
+	Object.keys(signatureOptions).forEach((key) => {
+		const pattern = `\${${key}}`;
+		const value = Array.isArray(signatureOptions[key]) ? signatureOptions[key].join(" ") : signatureOptions[key];
+		sig = sig.replace(pattern, value);
+	});
+	return sig;
+}
+function generateSignatureHeaders(request, environment) {
+	const curDate = (/* @__PURE__ */ new Date()).toUTCString();
+	const targetUrl = request.url.trim().replace(/^https?:\/\/[^/]+\//, "/");
+	const method = request.method.toLowerCase();
+	const computedDigest = `SHA-256=${crypto.createHash("sha256").update(request.data).digest().toString("base64")}`;
+	const postHeaderHash = {
+		"host": environment.host,
+		"date": curDate,
+		"(request-target)": `${method} ${targetUrl}`,
+		"digest": computedDigest,
+		"v-c-merchant-id": environment.merchantId
+	};
+	const getHeaderHash = {
+		"host": environment.host,
+		"date": curDate,
+		"(request-target)": `${method} ${targetUrl}`,
+		"v-c-merchant-id": environment.merchantId
+	};
+	const postConfig = {
+		algorithm: "HmacSHA256",
+		keyid: environment.keyId,
+		secretkey: environment.secretkey,
+		headers: [
+			"host",
+			"date",
+			"(request-target)",
+			"digest",
+			"v-c-merchant-id"
+		]
+	};
+	const getConfig = {
+		algorithm: "HmacSHA256",
+		keyid: environment.keyId,
+		secretkey: environment.secretkey,
+		headers: [
+			"host",
+			"date",
+			"(request-target)",
+			"v-c-merchant-id"
+		]
+	};
+	let config;
+	let headerHash;
+	if ([
+		"post",
+		"put",
+		"patch"
+	].includes(method)) {
+		config = postConfig;
+		headerHash = postHeaderHash;
+	} else if (["get", "delete"].includes(method)) {
+		config = getConfig;
+		headerHash = getHeaderHash;
+	} else throw new Error(`Unsupported HTTP method: ${method}`);
+	return {
+		sig: computeHttpSignature(config, headerHash),
+		computedDigest,
+		curDate,
+		targetUrl,
+		signingBase: Object.values(headerHash).join("\n"),
+		method
+	};
+}
+async function setupAuthentication(api, { card, clientReferenceInformation, buyerInformation }) {
+	console.log(buyerInformation);
+	return await api("/risk/v1/authentication-setups", {
+		method: "POST",
+		body: {
+			clientReferenceInformation,
+			buyerInformation,
+			paymentInformation: { card }
+		}
+	});
+}
+const createCybersource = ({ hostEndpoint, keyId, secretkey, merchantId }) => {
+	const api = ofetch.create({
+		baseURL: `https://${hostEndpoint}`,
+		onRequest({ request, options }) {
+			const h = generateSignatureHeaders({
+				url: `https://${hostEndpoint}${request}`,
+				method: options.method,
+				data: JSON.stringify(options.body || {})
+			}, {
+				host: hostEndpoint,
+				merchantId,
+				keyId,
+				secretkey
+			});
+			options.headers.append("v-c-merchant-id", merchantId);
+			options.headers.append("Date", h.curDate);
+			options.headers.append("Host", hostEndpoint);
+			if (!["get", "delete"].includes(h.method)) options.headers.append("Digest", h.computedDigest);
+			options.headers.append("Signature", h.sig);
+			options.headers.append("Accept", "*/*");
+			options.headers.append("Content-Type", "application/json");
+		}
+	});
+	return {
+		methods: { recurrent: async (body) => {
+			return await api("/pts/v2/payments", {
+				method: "POST",
+				body: {
+					clientReferenceInformation: { code: body.code },
+					processingInformation: {
+						commerceIndicator: "recurring",
+						capture: true,
+						authorizationOptions: {
+							ignoreAvsResult: false,
+							declineAvsFlags: null,
+							ignoreCvResult: false,
+							initiator: {
+								type: "merchant",
+								credentialStoredOnFile: null,
+								merchantInitiatedTransaction: {
+									reason: body.reason || "1",
+									previousTransactionId: body.previousTransactionId
+								}
+							},
+							billPayment: null
+						},
+						captureOptions: null
+					},
+					paymentInformation: { customer: { customerId: body.customerId } },
+					instrumentIdentifier: { id: body.instrumentIdentifierId },
+					orderInformation: {
+						amountDetails: {
+							totalAmount: body.totalAmount,
+							currency: body.currency || "BOB"
+						},
+						billTo: {
+							firstName: body.firstName || "",
+							lastName: body.lastName || ""
+						},
+						shipTo: null
+					},
+					buyerInformation: null,
+					recipientInformation: null,
+					deviceInformation: { hostName: null }
+				}
+			});
+		} },
+		prepare: async (uid, transaction, options) => {
+			const { card } = options;
+			if (!card) throw new Error("Card information is required for Cybersource prepare");
+			const r = await setupAuthentication(api, {
+				card,
+				clientReferenceInformation: { code: transaction.id },
+				buyerInformation: {
+					merchantCustomerID: transaction.session.identification,
+					email: transaction.session.email
+				}
+			});
+			return {
+				id: r.id,
+				iframe: r,
+				extras: { setup: r }
+			};
+		},
+		postPrepare: async (uid, transaction, options) => {
+			const { card, body, transactionMode, returnUrl, deviceInformation, merchantDefinedInformation } = options;
+			if (!card) throw new Error("Card information is required for Cybersource prepare");
+			let iframe = {};
+			const extras = {};
+			const orderInformation = {
+				amountDetails: {
+					currency: transaction.checkout.billingInfo.currency || "BOB",
+					totalAmount: transaction.checkout.total
+				},
+				billTo: {
+					address1: transaction.checkout.billingInfo.address1 || "Zona sur",
+					address2: transaction.checkout.billingInfo.address2 || "Calacoto",
+					administrativeArea: transaction.checkout.billingInfo.administrativeArea || null,
+					country: transaction.checkout.billingInfo.country || "BO",
+					locality: transaction.checkout.billingInfo.locality || "La Paz",
+					firstName: transaction.checkout.billingInfo.firstName || "Ivan",
+					lastName: transaction.checkout.billingInfo.lastName || "Olguin",
+					phoneNumber: transaction.checkout.billingInfo.phone || "N/A",
+					email: transaction.checkout.billingInfo.email || "N/A",
+					postalCode: transaction.checkout.billingInfo.postalCode || "94105"
+				}
+			};
+			if (body.referenceId) {
+				const payload = {
+					clientReferenceInformation: { code: transaction.id },
+					orderInformation,
+					paymentInformation: { card },
+					consumerAuthenticationInformation: {
+						returnUrl: `${returnUrl}/payment/cybersource/return`,
+						transactionMode: transactionMode || "S",
+						referenceId: body.referenceId
+					},
+					buyerInformation: {
+						merchantCustomerID: transaction.session.identification,
+						email: transaction.session.email
+					}
+				};
+				if (deviceInformation) payload.deviceInformation = {
+					...deviceInformation,
+					phoneNumber: transaction.checkout.billingInfo.phone || "",
+					email: transaction.checkout.billingInfo.email || "",
+					firstName: transaction.checkout.billingInfo.firstName || "N/A",
+					lastName: transaction.checkout.billingInfo.lastName || "N/A"
+				};
+				if (merchantDefinedInformation) payload.merchantDefinedInformation = merchantDefinedInformation || [];
+				console.log("Request:", "/risk/v1/authentications ::", payload);
+				iframe = await api("/risk/v1/authentications", {
+					method: "POST",
+					body: payload
+				}).catch((e) => {
+					console.error("Error in Cybersource authentication:", e);
+					throw e;
+				});
+				extras.enrollment = iframe;
+			}
+			if (body.authenticationTransactionId) {
+				const payload = {
+					buyerInformation: {
+						merchantCustomerID: transaction.session.identification,
+						email: transaction.session.email
+					},
+					clientReferenceInformation: { code: transaction.id },
+					orderInformation,
+					paymentInformation: { card },
+					consumerAuthenticationInformation: { authenticationTransactionId: body.authenticationTransactionId }
+				};
+				if (deviceInformation) payload.deviceInformation = {
+					...deviceInformation,
+					phoneNumber: transaction.checkout.billingInfo.phone || "",
+					email: transaction.checkout.billingInfo.email || "",
+					firstName: transaction.checkout.billingInfo.firstName || "N/A",
+					lastName: transaction.checkout.billingInfo.lastName || "N/A"
+				};
+				if (merchantDefinedInformation) payload.merchantDefinedInformation = merchantDefinedInformation || [];
+				console.log("Request:", "/risk/v1/authentication-results ::", payload);
+				iframe = await api("/risk/v1/authentication-results", {
+					method: "POST",
+					body: payload
+				});
+				extras.authentication = iframe;
+			}
+			return {
+				id: transaction.ref,
+				iframe,
+				extras
+			};
+		},
+		sendPay: async ({ uid, body }, { transaction }) => {
+			const { card, consumer, processingInformation, deviceInformation, merchantDefinedInformation } = body;
+			if (!card) throw new Error("Card information is required for Cybersource prepare");
+			const orderInformation = {
+				amountDetails: {
+					currency: transaction.checkout.billingInfo.currency || "BOB",
+					totalAmount: transaction.checkout.total
+				},
+				billTo: {
+					address1: transaction.checkout.billingInfo.address1 || "Zona sur",
+					address2: transaction.checkout.billingInfo.address2 || "Colacoto",
+					administrativeArea: transaction.checkout.billingInfo.administrativeArea || null,
+					country: transaction.checkout.billingInfo.country || "BO",
+					locality: transaction.checkout.billingInfo.locality || "La Paz",
+					firstName: transaction.checkout.billingInfo.firstName || "Ival",
+					lastName: transaction.checkout.billingInfo.lastName || "Olguin",
+					phoneNumber: transaction.checkout.billingInfo.phone || "N/A",
+					email: transaction.checkout.billingInfo.email || "N/A",
+					postalCode: transaction.checkout.billingInfo.postalCode || "94105"
+				}
+			};
+			const payload = {
+				clientReferenceInformation: { code: transaction.id },
+				buyerInformation: {
+					merchantCustomerID: transaction.session.identification,
+					email: transaction.session.email
+				},
+				orderInformation,
+				paymentInformation: { card },
+				processingInformation,
+				consumerAuthenticationInformation: consumer,
+				deviceInformation: {},
+				merchantDefinedInformation: []
+			};
+			if (deviceInformation) payload.deviceInformation = {
+				...deviceInformation,
+				phoneNumber: transaction.checkout.billingInfo.phone || "",
+				email: transaction.checkout.billingInfo.email || "",
+				firstName: transaction.checkout.billingInfo.firstName || "N/A",
+				lastName: transaction.checkout.billingInfo.lastName || "N/A"
+			};
+			if (merchantDefinedInformation) payload.merchantDefinedInformation = merchantDefinedInformation || [];
+			console.log("Request:", "/pts/v2/payments::", payload);
+			const r = await api("/pts/v2/payments", {
+				method: "POST",
+				body: payload
+			});
+			console.log("Response:", "/pts/v2/payments::", r);
+			let status = "pending";
+			if (r.status === "AUTHORIZED") status = "success";
+			if (["DECLINED", "CANCELLED"].includes(r.status)) status = "failure";
+			if (r.status === "PENDING") status = "pending";
+			return {
+				id: r.id,
+				uid,
+				status,
+				body: r,
+				message: ""
+			};
+		},
+		verify: async ({ uid, transaction }) => {
+			const self = transaction.details._links?.self?.href;
+			let reason = "";
+			let message = "";
+			let msg = "Estado desconocido";
+			if (self) {
+				const r = await api(self, { method: "GET" });
+				reason = r.statusInformation?.reason || "";
+				message = r.statusInformation?.message || "";
+			}
+			if (reason === "Success") msg = "Pago exitoso";
+			if (reason === "Declined") msg = "Pago declinado";
+			else if (reason === "Cancelled") msg = "Pago cancelado";
+			else if (reason === "Pending") msg = "Pago pendiente";
+			else if (reason === "Error") msg = "Error en el pago";
+			return {
+				id: transaction.id,
+				status: transaction.status,
+				details: {
+					messages: { es: msg },
+					status: transaction.status,
+					code: reason,
+					description: message
+				},
+				payments: {
+					current: {},
+					history: []
+				},
+				responseRaw: transaction.details,
+				uid,
+				customer: transaction.session.customer,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status
+				}
+			};
+		},
+		refund: async () => {
+			return {};
+		}
+	};
+};
+function createBodyDatafast(uid, { checkout, session, ip }, credentials) {
+	const amount = (+`${checkout.total}`).toFixed(2);
+	const sCountryCode = checkout.shippingInfo?.countryCode;
+	const bCountryCode = checkout.billingInfo?.countryCode || sCountryCode;
+	if (+`${credentials.fase}` === 1) return [
+		`entityId=${credentials.entityId}`,
+		"amount=12.00",
+		"currency=USD",
+		"paymentType=DB"
+	].join("&");
+	if (!session.email || !session.identification || !ip) throw new Error("Missing required session fields");
+	const body = {
+		entityId: credentials.entityId,
+		merchantTransactionId: uid,
+		amount: `${amount}`,
+		currency: "USD",
+		paymentType: "DB",
+		shipping: {
+			street1: checkout.shippingInfo?.address || "NA",
+			country: sCountryCode || "EC"
+		},
+		billing: {
+			street1: checkout.billingInfo?.address || checkout.shippingInfo?.address || "NA",
+			country: bCountryCode || "EC"
+		},
+		customer: {
+			email: session.email,
+			identificationDocType: "IDCARD",
+			identificationDocId: session.identification,
+			givenName: session.customer.givenName,
+			middleName: session.customer.middleName || "NA",
+			surname: session.customer.surname,
+			ip,
+			merchantCustomerId: session.customer.id,
+			phone: session.customer.phone || "0999999999"
+		}
+	};
+	const itemsStr = checkout.items.map((el, ix) => {
+		return [
+			`cart.items[${ix}].name=${encodeURIComponent(el.title)}`,
+			`cart.items[${ix}].description=${encodeURIComponent(`Description:${el.title}`)}`,
+			`cart.items[${ix}].price=${encodeURIComponent(Number(`${el.item.unitAmount}`).toFixed(2))}`,
+			`cart.items[${ix}].quantity=${encodeURIComponent(el.quantity)}`
+		].join("&");
+	}).join("&");
+	const base0 = checkout.taxes.find((el) => el.code === "0")?.base || 0;
+	const baseIVA = checkout.taxes.find((el) => el.code === credentials.codeIva || "4")?.base || 0;
+	const taxIVA = checkout.taxes.find((el) => el.code === credentials.codeIva || "4")?.value || 0;
+	const cp = {
+		"customParameters[SHOPPER_MID]": credentials.mid,
+		"customParameters[SHOPPER_TID]": credentials.tid,
+		"customParameters[SHOPPER_ECI]": "0103910",
+		"customParameters[SHOPPER_PSERV]": "17913101",
+		"customParameters[SHOPPER_VAL_BASE0]": base0?.toFixed(2),
+		"customParameters[SHOPPER_VAL_BASEIMP]": baseIVA?.toFixed(2),
+		"customParameters[SHOPPER_VAL_IVA]": taxIVA?.toFixed(2),
+		"customParameters[SHOPPER_VERSIONDF]": "2"
+	};
+	const str = [
+		qs.stringify(body, { allowDots: true }),
+		itemsStr,
+		Object.entries(cp).map(([key, value]) => {
+			return `${key}=${value}`;
+		}).join("&"),
+		`risk.parameters[USER_DATA2]=${credentials.nameEcommerce}`
+	];
+	if (+`${credentials.fase}` !== 3) str.push("testMode=EXTERNAL");
+	return str.join("&");
+}
+function numberOfInstallments(installments = []) {
+	const option = (value, index) => `<option value="${value}" ${index === 0 ? "selected" : ""}>${value} meses</option>`;
+	const disabled = installments.length > 1 ? "" : "disabled";
+	const display = "inline-block";
+	return installments.length ? `
+    <div class="wpwl-label wpwl-label-custom" style="display:${display}">
+      Diferido:
+    </div>
+    <div class="wpwl-wrapper wpwl-wrapper-custom" style="display:${display}">
+      <select name="recurring.numberOfInstallments" ${disabled}>
+        ${installments.map(option).join(" ")}
+      </select>
+    </div>
+  ` : "";
+}
+const dicCreditTypes = {
+	"00": "Transacción corriente",
+	"01": "Diferido corriente",
+	"02": "Diferido con Interés",
+	"03": "Diferido sin Interés",
+	"07": "Diferido con Interés + Meses de Gracia",
+	"09": "Diferido sin Interés + Meses de Gracia",
+	"21": "Diferido Plus",
+	"22": "Diferido"
+};
+function creditType(options = false) {
+	let selectOptions = [];
+	const option = ([key], index) => `<option value="${key}" ${index === 0 ? "selected" : ""}>${dicCreditTypes[key]}</option>`;
+	if (typeof options === "boolean") {
+		if (!options) return "";
+		selectOptions = Object.entries(dicCreditTypes).sort(([keyA], [keyB]) => +keyA - +keyB).map(option);
+	} else selectOptions = Object.entries(options).filter(([, value]) => {
+		return value;
+	}).sort(([keyA], [keyB]) => +keyA - +keyB).map(option);
+	const display = "inline-block";
+	const disabled = selectOptions.length > 1 ? "" : "disabled";
+	return selectOptions ? ` <div
+    class="wpwl-wrapper wpwl-wrapper-custom"
+    style="display:${display};padding-left: 10px;padding-bottom: 15px;"
+  >
+    Tipo de crédito:
+    <select name="customParameters[SHOPPER_TIPOCREDITO]" style="max-width: 190px;" ${disabled}>
+      ${selectOptions.join(" ")}
+    </select>
+  </div>` : "";
+}
+function loadIframe(siteUrl, credentials) {
+	return (checkoutId, endpoint = `${siteUrl || ""}/payment/pay/datafast`, searchParams = {}, options) => {
+		const _searchParams = Object.entries(searchParams).map(([key, value]) => `${key}=${value}`).join("&");
+		const brands = options.brands?.join(" ")?.trim();
+		const scriptInstallments = (element) => element ? `
+    const nI = document.createElement('div');
+    nI.style.display='inline-block';
+    nI.innerHTML = '${element.replace(/\n/g, " ")}';
+    document.querySelector('form.wpwl-form-card .wpwl-button').before(nI);
+        ` : "";
+		const scriptTypeCredits = (element) => element ? `
+    const tC = document.createElement('div');
+    tC.style.display='inline-block';
+    tC.innerHTML = '${element.replace(/\n/g, " ")}';
+    document.querySelector('form.wpwl-form-card .wpwl-button').before(tC);
+    ` : "";
+		const installments = numberOfInstallments(options.installments);
+		const typeCredits = creditType(options.typeCredits);
+		const addLogo = options.logo ? `const Br = document.createElement('div');
+  Br.innerHTML ='<br/><img src="https://www.datafast.com.ec/images/verified.png" style="display:block;margin:0 auto; width:100%"><br/>';
+  document.querySelector('form.wpwl-form-card .wpwl-button').before(Br);` : "";
+		return `
+            <style>
+            body {
+              font-family: sans-serif;
+            }
+            .wpwl-form-card {
+              background-image: none;
+            }
+          </style>
+
+          ${`
+    <script type="text/javascript">
+      var wpwlOptions = {
+        locale: 'es',
+        labels: {
+          cvv: 'CVV',
+          cardHolder: "Nombre(Igual que en la tarjeta)"
+        },
+        onReady: function () {
+          ${scriptInstallments(installments)}
+          ${scriptTypeCredits(typeCredits)}
+          ${addLogo}
+        },
+        onBeforeSubmitCard: function () {
+            console.log('validate')
+          if (document.querySelector('.wpwl-control-cardHolder').value === '') {
+            const ch = document.querySelector('.wpwl-control-cardHolder');
+            ch.classList.add('wpwl-has-error');
+            const er = document.createElement('div');
+            er.classList.add('wpwl-hint');
+            er.classList.add('wpwl-hint-cardHolderError');
+
+            er.innerHTML = 'Campo requerido';
+            ch.after(er);
+            const btp = document.querySelector('.wpwl-button-pay');
+            btp.classList.add('wpwl-button-error');
+            btp.setAttribute('disabled', 'disabled');
+            return false
+          } else {
+            return true;
+          }
+        },
+      };
+    <\/script>
+  `}
+          <form
+            action="${endpoint}?${_searchParams}"
+            class="paymentWidgets"
+            data-brands="${brands || "VISA MASTER DISCOVER AMEX DINERS"}"
+          ></form>
+          <script src='${credentials.endpoint || "https://test.oppwa.com/v1"}/paymentWidgets.js?checkoutId=${checkoutId}'><\/script>
+            `;
+	};
+}
+const codes$4 = {
+	"000.000.000": {
+		status: "success",
+		description: "Transaction succeeded",
+		messages: { es: "Transacción aprobada" }
+	},
+	"000.100.110": {
+		status: "success",
+		description: "Request successfully processed in Merchant in Integrator Test Mode",
+		messages: { es: "Transacción aprobada" }
+	},
+	"000.100.112": {
+		status: "success",
+		description: "",
+		messages: { es: "Transacción aprobada" }
+	},
+	"000.000.100": {
+		status: "success",
+		description: "",
+		messages: { es: "Transacción aprobada" }
+	},
+	"000.200.100": {
+		status: "success",
+		description: "successfully created checkout",
+		messages: { es: "Creación del id (checkoutId) de manera exitosa" }
+	},
+	"600.200.201": {
+		status: "failure",
+		description: "Channel/Merchant not configured for this payment method",
+		messages: { es: "MID o TID mal configurado" }
+	},
+	"800.110.100": {
+		status: "failure",
+		description: "Duplicate transaction",
+		messages: { es: "Envio de transacción duplicado" }
+	},
+	"200.100.101": {
+		status: "pending",
+		description: "invalid Request Message. No valid XML. XML must be url-encoded! maybe it contains a not encoded ampersand or something similar.",
+		messages: { es: "Cédula de identidad, teléfono entre otro. Si todo está bien, entonces se debe revisar el campo Response, si tiene el valor de 05" },
+		pendingAction: (body) => {
+			return body.resultDetails.Response === "05" ? "pending" : "failure";
+		}
+	},
+	"200.100.103": {
+		status: "failure",
+		description: "Invalid Request Message. The request contains structural errors",
+		messages: { es: "Mensaje invalido. Verifique los datos enviados" }
+	},
+	"800.100.171": {
+		status: "failure",
+		description: "Transaction declined (pick up card)",
+		messages: { es: "Pick up: Retenga y llame" }
+	},
+	"700.300.700": {
+		status: "failure",
+		description: "referenced tx can not be reversed",
+		messages: { es: "Reverso declinado" }
+	},
+	"800.100.174": {
+		status: "failure",
+		description: "transaction declined (invalid amount)",
+		messages: { es: "Mondo invalido" }
+	},
+	"800.100.151": {
+		status: "failure",
+		description: "transaction declined (invalid card)",
+		messages: { es: "Tarjeta de crédito inválida" }
+	},
+	"800.100.402": {
+		status: "failure",
+		description: "cc/bank account holder not valid",
+		messages: { es: "No such issuer. Omisión de nombre de tarjetahabiente." }
+	},
+	"800.100.190": {
+		status: "failure",
+		description: "transaction declined (invalid configuration data)",
+		messages: { es: "Transacción declinada por el banco: 1: tipo de crédito que no autorizada 2: Tarjeta no autodizada 3: Banco funora de red " }
+	},
+	"800.100.152": {
+		status: "failure",
+		description: "Authorization Error (95) transaction declined by authorization system",
+		messages: { es: "La transacción fue rechazada por el banco" }
+	},
+	"800.100.197": {
+		status: "failure",
+		description: "transaction declined (registration cancelled externally)",
+		messages: { es: "Transacción cancelada por el cliente" }
+	},
+	"800.100.176": {
+		status: "failure",
+		description: "transaction declined (account temporarily not available. Please try again later)",
+		messages: { es: "Transacción rechazada: cuenta temporalmente no disponible, porfavor intente mas tarde" }
+	},
+	"100.400.311": {
+		status: "failure",
+		description: "transaction declined (format error)",
+		messages: { es: " Error de formato" }
+	},
+	"100.100.100": {
+		status: "failure",
+		description: "request contains no creditcard, bank account number or bank name",
+		messages: { es: "No se envió datos de la tarjeta" }
+	},
+	"800.100.165": {
+		status: "failure",
+		description: "transaction declined (card lost)",
+		messages: { es: "Tarjeta reportada como perdida" }
+	},
+	"800.100.159": {
+		status: "failure",
+		description: "transaction declined (stolen card)",
+		messages: { es: "Tarjeta reportada como sustraída" }
+	},
+	"800.100.155": {
+		status: "failure",
+		description: "transaction declined (amount exceeds credit)",
+		messages: { es: "Fondos insuficientes" }
+	},
+	"100.100.400": {
+		status: "failure",
+		description: "request contains no cc/bank account holder",
+		messages: { es: "Se envía vacío el cardholder" }
+	},
+	"100.100.303": {
+		status: "failure",
+		description: "Card Expired",
+		messages: { es: "Tarjeta expirada" }
+	},
+	"800.100.170": {
+		status: "failure",
+		description: "transaction declined (transaction not permitted)",
+		messages: { es: "Tarjeta de débito que no puede realizar compras por internet." }
+	},
+	"100.550.310": {
+		status: "failure",
+		description: "amount exceeds limit for the registered account",
+		messages: { es: "Monto excede el cupo" }
+	},
+	"800.100.168": {
+		status: "failure",
+		description: "transaction declined (restricted card)",
+		messages: { es: "Tarjeta restringida, cliente debe llamar al banco." }
+	},
+	"800.100.179": {
+		status: "failure",
+		description: "transaction declined (exceed withdrawal count limit)",
+		messages: { es: "Maximo transacciones permitidas" }
+	},
+	"100.100.402": {
+		status: "failure",
+		description: "cc/bank account holder not valid",
+		messages: { es: "Cardholder inválido, puede ser que tenga caracteres especiales" }
+	},
+	"600.200.100": {
+		status: "failure",
+		description: "invalid Payment Method",
+		messages: { es: "Modalidad invalida" }
+	},
+	"700.100.200": {
+		status: "failure",
+		description: "non matching reference amount",
+		messages: { es: "Verifique interés" }
+	},
+	"700.400.200": {
+		status: "failure",
+		description: "cannot refund",
+		messages: { es: "Se intentó anular una transacción que ya había sido anulada previamente" }
+	},
+	"800.100.157": {
+		status: "failure",
+		description: "transaction declined (wrong expiry date)",
+		messages: { es: "transaction declined (wrong expiry Vigencia de la tarjeta errada" }
+	},
+	"800.100.501": {
+		status: "failure",
+		description: "Card holder has advised his bank to stop all recurring payments for this merchant",
+		messages: { es: "Establecimiento cancelado" }
+	},
+	"800.100.100": {
+		status: "failure",
+		description: "transaction declined for unknown reason",
+		messages: { es: "1.La tarjeta tiene problemas por lo que el cliente debe llamar al Banco. 2.Transacción con una tarjeta de débito que no tiene autorizado compras por internet." }
+	},
+	"800.300.500": {
+		status: "failure",
+		description: "transaction temporary blacklisted (too many tries invalid CVV)",
+		messages: { es: "La tarjeta se encuentra en lista negra debido a múltiples intentos de transacciones con CVV errado, se libera después de 48 horas." }
+	},
+	"800.300.501": {
+		status: "failure",
+		description: "transaction temporary blacklisted (too many tries invalid expire date)",
+		messages: { es: "La tarjeta se encuentra en lista negra debido a múltiples intentos de transacciones con fecha de caducidad errada, se libera después de 48 horas." }
+	},
+	"900.100.201": {
+		status: "pending",
+		description: "error on the external gateway (bank)",
+		messages: { es: "Se ha perdido la conexión con el Gateway de Pagos," }
+	},
+	"900.100.100": {
+		status: "pending",
+		description: "unexpected communication error with connector/acquirer",
+		messages: { es: "Se ha perdido la conexión con el banco, intentar luego de unos minutos." }
+	},
+	"900.100.300": {
+		status: "pending",
+		description: "no response from connector/acquirer [uncertain result]",
+		messages: { es: "Existió una desconexión en el instante de la transacción," }
+	},
+	"800.100.199": {
+		status: "failure",
+		description: "transaction declined (invalid tax number)",
+		messages: { es: "Mensaje emitido cuando se ha calculado mal los impuestos, la base 0% + la base 12% + valor del IVA debe ser igual al monto que se envía." }
+	},
+	"600.200.500": {
+		status: "failure",
+		description: "Invalid payment data. You are not configured for this currency or sub type (country or brand)",
+		messages: { es: "Mensaje emitido cuando no se ha asignado una marca de tarjeta para transaccionar." }
+	},
+	"800.100.156": {
+		status: "failure",
+		description: "transaction declined (format error)",
+		messages: { es: "Depende del valor del código en el campo Response" }
+	},
+	"800.100.162": {
+		status: "failure",
+		description: "Transaction declined (limit exceeded)",
+		messages: { es: "La tarjeta tiene un límite en el monto en compras, aún teniendo cupo." }
+	},
+	"100.100.101": {
+		status: "failure",
+		description: "invalid creditcard, bank account number or bank name",
+		messages: { es: "Tarjeta de crédito inválida" }
+	},
+	"100.700.801": {
+		status: "failure",
+		description: "identity contains no or invalid identification value",
+		messages: { es: "Se está enviando un campo mal, ya sea en el nombre o en su valor, el técnico debe revisar internamente." }
+	},
+	"100.400.147": {
+		status: "failure",
+		description: "Payment void and transaction denied by ReD Shield",
+		messages: { es: "La transacción infringió una regla antifraude. Estas reglas fueron definidas por el comercio al momento de firmar." }
+	},
+	"100.400.149": {
+		status: "failure",
+		description: "Payment void and transaction denied by ReD Shield",
+		messages: { es: "La transacción infringió una regla antifraude. Estas reglas fueron definidas por el comercio al momento de firmar." }
+	},
+	"100.400.325": {
+		status: "failure",
+		description: "External risk system not available",
+		messages: { es: "Si este mensaje se presenta en muchas transacciones entonces el comercio debe comunicarse con Datafast de manera inmediata." }
+	},
+	"100.380.401": {
+		status: "failure",
+		description: "User Authentication Failed. (3DSecure Error)",
+		messages: { es: "El código ingresado por el tarjetahabiente es incorrecto." }
+	},
+	"100.380.501": {
+		status: "failure",
+		description: "User Authentication Error (risk management transaction timeout)",
+		messages: { es: "El tarjetahabiente no digitó el código enviado por el banco dentro del tiempo establecido." }
+	},
+	"100.396.103": {
+		status: "failure",
+		description: "Previously pending transaction timed out (Error in asynchronous workflow)",
+		messages: { es: "El tarjetahabiente no digitó el código enviado por el banco dentro del tiempo establecido para tarjetas" }
+	},
+	"100.390.108": {
+		status: "failure",
+		description: "Transaction rejected because merchant not participating in 3DSecure program (3DSecure Error)",
+		messages: { es: "Error de configuración en el canal." }
+	},
+	"100.390.112": {
+		status: "failure",
+		description: "Technical Error in 3D system (3DSecure Error)",
+		messages: { es: "Error de configuración en el canal." }
+	}
+};
+function handleControlCodes$1(body) {
+	const code = codes$4[body.result.code];
+	if (!code) return {
+		status: "pending",
+		code: body.result.code,
+		description: "unknow code",
+		messages: { es: "Codigo desconocido" }
+	};
+	return {
+		...code,
+		code: body.result.code
+	};
+}
+function sendPay({ credentials }) {
+	return async ({ id }, { uid }) => {
+		const body = await ofetch(`${credentials.endpoint}/checkouts/${id}/payment?entityId=${credentials.entityId}`, { headers: { Authorization: `Bearer ${credentials.token}` } });
+		const state = handleControlCodes$1(body);
+		return {
+			id: body.id,
+			uid,
+			status: state.status,
+			message: state.messages.es,
+			body
+		};
+	};
+}
+const createDatafast = (options) => {
+	const { credentials, urlSite } = options;
+	return {
+		methods: {},
+		prepare: async (uid, transaction, options = {}) => {
+			const data = createBodyDatafast(uid, transaction, credentials);
+			if (options?.fake) return data;
+			const r = await ofetch(`${credentials.endpoint}/checkouts`, {
+				method: "POST",
+				body: data,
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded",
+					"Content-Length": `${data.length}`,
+					"Authorization": `Bearer ${credentials.token}`
+				}
+			});
+			const iframe = loadIframe(urlSite, credentials)(r.id, options.endpoint, {
+				...options?.searchParams,
+				uid: transaction.id
+			}, { ...options?.iframe });
+			return {
+				id: r.id,
+				...r,
+				iframe
+			};
+		},
+		sendPay: sendPay({ credentials }),
+		verify: async ({ uid, transaction }) => {
+			const r = await ofetch(`${credentials.endpoint}/query?entityId=${credentials.entityId}&merchantTransactionId=${uid}`, { headers: { Authorization: `Bearer ${credentials.token}` } });
+			const payments = r.payments || [];
+			const history = payments.filter((el) => el.paymentType !== "RF");
+			const refunds = payments.filter((el) => el.paymentType === "RF");
+			const last = payments[payments.length - 1];
+			const h = handleControlCodes$1(last);
+			return {
+				id: last.id,
+				status: h.status,
+				details: h,
+				payments: {
+					current: history[history.length - 1],
+					history,
+					refunds
+				},
+				responseRaw: r,
+				uid,
+				customer: payments[0]?.customer,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status
+				}
+			};
+		},
+		refund: async (ref, amount, options = {}) => {
+			return await ofetch(`${credentials.endpoint}/payments/${ref}`, {
+				method: "POST",
+				body: `entityId=${credentials.entityId}&paymentType=RF&amount=${Number(`${amount}`).toFixed(2)}&currency=${options.currency || "USD"}${+credentials.fase !== 3 ? "&testMode=EXTERNAL" : ""}`,
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded",
+					"Authorization": `Bearer ${credentials.token}`
+				}
+			});
+		}
+	};
+};
+function createBodyMultipago$1(uid, { session, checkout }, options) {
+	return {
+		service: { code: options.code },
+		payment_data: {
+			item_selecteds: checkout.items.map((item) => {
+				return {
+					id: item.id || 34,
+					description: `${item.title}`,
+					quantity: `${item.quantity}`,
+					unitary_price: `${item.item.unitAmount}`
+				};
+			}),
+			payment_receiver: {
+				id_local: null,
+				name: null,
+				ci: null,
+				account_type: null,
+				account_num: null,
+				bank: null
+			},
+			url_confirm: `${options.urlReturn}&status=success`,
+			url_fail: `${options.urlReturn}&status=failure`,
+			button_label_ok: "OK",
+			color: "",
+			font: ""
+		},
+		client: {
+			name: session.customer.givenName,
+			last_name: session.customer.surname,
+			ci: session.identification,
+			phone: session.customer.phone || "",
+			email: session.email,
+			business_name: session.customer?.extras?.businessName || "",
+			nit: session.customer?.extras?.nit || ""
+		}
+	};
+}
+const codes$3 = {
+	pendiente: {
+		status: "created",
+		messages: { es: "Orden de pago creada" }
+	},
+	pediente: {
+		status: "created",
+		messages: { es: "Orden de pago creada" }
+	},
+	confirmada: {
+		status: "success",
+		messages: { es: "Pago aprobada" }
+	},
+	cancelada: {
+		status: "failure",
+		messages: { es: "Transacción cancelada" }
+	},
+	error: {
+		status: "failure",
+		messages: { es: "Sesión de transacción expirada" }
+	},
+	revertido: {
+		status: "refund",
+		messages: { es: "Transaccíon reversada" }
+	},
+	reservado: {
+		status: "pending",
+		messages: { es: "Pago pendiente" }
+	}
+};
+function normalizeStatus$2({ data }) {
+	const code = codes$3[data.status_order.toLowerCase().trim()];
+	if (!code) return {
+		status: "pending",
+		code: data.status_order || "??",
+		description: data?.detail?.payment_response || "unknow code",
+		messages: { es: "Codigo desconocido" }
+	};
+	return {
+		...code,
+		description: data?.detail?.payment_response,
+		code: data.status_order
+	};
+}
+const createMultipagos = ({ credentials, serviceCode, urlReturn }) => {
+	const getToken = async () => {
+		const token = await ofetch(joinURL(credentials.endpoint, "/api/v2/get_token"), {
+			method: "post",
+			body: {
+				provider: credentials.provider,
+				uid: credentials.uid
+			}
+		});
+		if (token.status !== "OK") throw token;
+		return token;
+	};
+	const createPayOrder = async (token, body) => {
+		return await ofetch(joinURL(credentials.endpoint, "/api/v2/external_services/payorders"), {
+			method: "post",
+			headers: { Authorization: token.data },
+			body
+		});
+	};
+	return {
+		prepare: async (uid, transaction, options) => {
+			const order = await createPayOrder(await getToken(), createBodyMultipago$1(uid, transaction, {
+				code: serviceCode,
+				urlReturn: `${urlReturn}?uid=${uid}&provider=multipago&${Object.entries(options?.params || {}).map(([key, value]) => `${key}=${value}`).join("&")}`
+			}));
+			return {
+				id: `${order.data.pay_order.pay_order_number}`,
+				iframe: order.data.url_to_pay,
+				order: order.data.pay_order,
+				sonda: dayjs().add(1, "day").valueOf()
+			};
+		},
+		sendPay: async ({ uid }, { transaction }) => {
+			const token = await getToken();
+			const r = await ofetch(`${credentials.endpoint}/api/v2/getPayOrderByNumber`, {
+				method: "post",
+				body: { pay_order_number: transaction.ref },
+				headers: { Authorization: token.data }
+			});
+			const details = normalizeStatus$2(r);
+			return {
+				id: transaction.ref,
+				uid,
+				status: details.status,
+				body: r,
+				message: details.description || details.messages?.es || "",
+				sonda: details.status !== "success" ? dayjs().add(1, "day").valueOf() : false
+			};
+		},
+		verify: async ({ transaction }) => {
+			const token = await getToken();
+			const r = await ofetch(`${credentials.endpoint}/api/v2/getPayOrderByNumber`, {
+				method: "post",
+				body: { pay_order_number: transaction.ref },
+				headers: { Authorization: token.data }
+			});
+			const details = normalizeStatus$2(r);
+			return {
+				id: transaction.ref,
+				status: details.status,
+				responseRaw: r,
+				details,
+				customer: transaction.session.customer || {},
+				payments: {
+					current: {},
+					history: []
+				},
+				uid: transaction.id,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status,
+					responseTasks: transaction.responseTasks,
+					payloadTasks: { success: transaction.tasks.success?.map((el) => {
+						return el.payload;
+					}) }
+				}
+			};
+		},
+		refund: async () => {
+			return {};
+		},
+		methods: {}
+	};
+};
+function createBodyMultipago(_uid, { session, checkout, id }, options) {
+	const base0 = checkout.taxes.find((el) => el.code === "0")?.base || 0;
+	let baseIVA = checkout.taxes.find((el) => el.code === "4")?.base || 0;
+	const taxIVA = checkout.taxes.find((el) => el.code === "4")?.value || 0;
+	console.log(checkout.taxes, session);
+	if (!session.email || !session.identification || !checkout.total) throw new Error("Missing required session fields: email, identification, or checkout total");
+	if (!base0 && !baseIVA && !taxIVA) baseIVA = +(checkout.total || 0);
+	const document_type = session.identification.length === 10 ? "05" : "04";
+	const description = `Compra en ecommerce ${options.storeName || ""}, transacción N°${id}`;
+	return {
+		integration: true,
+		third: {
+			name: [session.customer.givenName, session.customer.surname].join(" "),
+			document_type,
+			document: session.identification,
+			phones: session.customer.billingInfo?.phone || session.customer.phone || "",
+			email: session.email,
+			type: "Individual",
+			address: session.customer.billingInfo?.address || session.customer.address || "No disponible"
+		},
+		generate_invoice: 0,
+		description,
+		amount: +(checkout.total || 0),
+		amount_with_tax: +base0,
+		amount_without_tax: +baseIVA,
+		tax_value: +taxIVA,
+		settings: [],
+		notify_url: options.urlReturn,
+		has_cash: 0,
+		has_cards: 1
+	};
+}
+const codes$2 = {
+	0: {
+		status: "created",
+		messages: { es: "Orden de pago creada" }
+	},
+	1: {
+		status: "success",
+		messages: { es: "Pago aprobada" }
+	},
+	2: {
+		status: "failure",
+		messages: { es: "Transacción rechazada" }
+	},
+	3: {
+		status: "refund",
+		messages: { es: "Transaccíon reversada" }
+	}
+};
+function normalizeStatus$1({ data }) {
+	const payment = data[0];
+	const code = codes$2[payment.status];
+	if (!code) return {
+		status: "pending",
+		code: payment.reference || "??",
+		description: payment.description || "unknow code",
+		messages: { es: "Codigo desconocido" }
+	};
+	return {
+		...code,
+		description: payment.description,
+		code: payment.reference
+	};
+}
+const createPagomedios = ({ credentials, urlReturn, nameEcommerce }) => {
+	const getToken = async () => {
+		return `Bearer ${credentials.token}`;
+	};
+	const createPayOrder = async (token, body) => {
+		console.log(joinURL(credentials.endpoint, "/pagomedios/v2/payment-request"), token, body);
+		try {
+			return await ofetch(joinURL(credentials.endpoint, "/pagomedios/v2/payment-requests"), {
+				method: "post",
+				headers: { Authorization: token },
+				body
+			});
+		} catch (error) {
+			console.error(error);
+			console.error(error?.response?._data?.data);
+			throw error;
+		}
+	};
+	return {
+		prepare: async (uid, transaction, options) => {
+			const token = await getToken();
+			let returnUrl = `${urlReturn}?uid=${uid}&provider=pagomedios&${Object.entries(options?.params || {}).map(([key, value]) => `${key}=${value}`).join("&")}`;
+			returnUrl = returnUrl.replace("{{storeId}}", `${transaction.session.store.id}`);
+			const order = await createPayOrder(token, createBodyMultipago(uid, transaction, {
+				urlReturn: returnUrl,
+				storeName: nameEcommerce
+			}));
+			return {
+				id: `${order.data.token}`,
+				iframe: order.data.url,
+				sonda: dayjs().add(30, "minutes").valueOf()
+			};
+		},
+		sendPay: async ({ uid }, { transaction }) => {
+			const token = await getToken();
+			const r = await ofetch(`${credentials.endpoint}/pagomedios/v2/payment-requests`, {
+				method: "get",
+				query: { uuid: transaction.ref },
+				headers: { Authorization: token }
+			});
+			const details = normalizeStatus$1(r);
+			return {
+				id: transaction.ref,
+				uid,
+				status: details.status,
+				body: r,
+				message: details.description || details.messages?.es || "",
+				sonda: details.status !== "success" ? dayjs().add(1, "day").valueOf() : false
+			};
+		},
+		verify: async ({ transaction }) => {
+			const token = await getToken();
+			const r = await ofetch(`${credentials.endpoint}/pagomedios/v2/payment-requests`, {
+				method: "get",
+				query: { uuid: transaction.ref },
+				headers: { Authorization: token }
+			});
+			const details = normalizeStatus$1(r);
+			return {
+				id: transaction.ref,
+				status: details.status,
+				responseRaw: r,
+				details,
+				customer: transaction.session.customer || {},
+				payments: {
+					current: {},
+					history: []
+				},
+				uid: transaction.id,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status,
+					responseTasks: transaction.responseTasks,
+					payloadTasks: { success: transaction.tasks.success?.map((el) => {
+						return el.payload;
+					}) }
+				}
+			};
+		},
+		refund: async () => {
+			return {};
+		},
+		methods: {}
+	};
+};
+function createAuthToken(credentials) {
+	return () => {
+		const { code, key } = credentials;
+		const hash = crypto.createHash("sha256");
+		const timestamp = Math.floor(Date.now() / 1e3);
+		const uniqueToken = `${key}${timestamp}`;
+		hash.update(uniqueToken);
+		const uniqueHash = hash.digest("hex");
+		return Buffer.from(`${code};${timestamp};${uniqueHash}`).toString("base64");
+	};
+}
+function createPmzPayload(uid, { checkout, session, ip }, options) {
+	const base12 = checkout.taxes.find((el) => el.code === "2")?.base || 0;
+	const tax12 = checkout.taxes.find((el) => el.code === "2")?.value || 0;
+	return {
+		order: {
+			amount: +checkout.total,
+			taxable_amount: +base12,
+			dev_reference: uid,
+			description: "Buy in ecommerce",
+			vat: tax12,
+			tax_percentage: base12 === 0 ? 0 : 12
+		},
+		user: {
+			email: session.email || "",
+			id: session.customer.id,
+			ip_address: ip || "",
+			phone: session.customer.phone
+		},
+		card: options.card
+	};
+}
+function getAllCards(auth) {
+	return async (uid) => {
+		const res = auth();
+		return await ofetch("v2/card/list", {
+			baseURL: res.endpoint,
+			query: { uid },
+			headers: {
+				"Content-Type": "application/json",
+				"Auth-Token": res.authToken
+			}
+		}).catch((err) => {
+			console.error(err?.response?.body);
+			throw err;
+		});
+	};
+}
+function deleteCard(auth) {
+	return async (body) => {
+		const res = auth();
+		return await ofetch("v2/card/delete/", {
+			method: "POST",
+			baseURL: res.endpoint,
+			body,
+			headers: { "Auth-Token": res.authToken }
+		});
+	};
+}
+function debitWithToken(auth) {
+	return async (body) => {
+		const res = auth();
+		return await ofetch("v2/transaction/debit/", {
+			method: "POST",
+			baseURL: res.endpoint,
+			body,
+			headers: { "Auth-Token": res.authToken }
+		});
+	};
+}
+function verify(auth) {
+	return async (body, moreInfo) => {
+		const res = auth();
+		return await ofetch("v2/transaction/verify/", {
+			method: "POST",
+			baseURL: res.endpoint,
+			body: {
+				...body,
+				more_info: moreInfo
+			},
+			headers: { "Auth-Token": res.authToken }
+		});
+	};
+}
+function refund(auth) {
+	return async (body, moreInfo) => {
+		const res = auth();
+		return await ofetch("v2/transaction/refund/", {
+			method: "POST",
+			baseURL: res.endpoint,
+			body: {
+				...body,
+				more_info: moreInfo
+			},
+			headers: { "Auth-Token": res.authToken }
+		});
+	};
+}
+function transactionInfo(auth) {
+	return async (id) => {
+		const res = auth();
+		return await ofetch(`v2/transaction/${id}`, {
+			baseURL: res.endpoint,
+			headers: {
+				"Auth-Token": res.authToken,
+				"Content-Type": "application/json"
+			}
+		});
+	};
+}
+const createPaymentez = (options) => {
+	const URL_PROD = "https://ccapi.paymentez.com";
+	const URL_STG = "https://ccapi-stg.paymentez.com";
+	const URL_DEV = "http://localhost:3658";
+	const isProduction = options.mode === "production";
+	const getAuth = () => {
+		const endpoint = isProduction ? URL_PROD : options.mode === "staging" ? URL_STG : URL_DEV;
+		return {
+			authToken: createAuthToken(options.credentials)(),
+			endpoint
+		};
+	};
+	const methods = {
+		debitWithToken: debitWithToken(getAuth),
+		deleteCard: deleteCard(getAuth),
+		getAllCards: getAllCards(getAuth),
+		refund: refund(getAuth),
+		transactionInfo: transactionInfo(getAuth),
+		verify: verify(getAuth)
+	};
+	return {
+		prepare: async () => {
+			return { id: "" };
+		},
+		sendPay: async ({ uid, card }, { transaction }) => {
+			const body = createPmzPayload(uid, transaction, { card: { token: card } });
+			try {
+				const response = await debitWithToken(getAuth)(body);
+				return {
+					id: response.transaction.id,
+					uid,
+					status: response.transaction.status,
+					body: response.transaction,
+					message: response.transaction.message
+				};
+			} catch (error) {
+				console.error(error.response.body);
+				throw error;
+			}
+		},
+		verify: async ({ transaction }) => {
+			const r = await methods.transactionInfo(transaction.ref);
+			return {
+				id: transaction.ref,
+				status: r.transaction.status,
+				customer: {},
+				details: {
+					messages: { es: r.transaction.message },
+					status: r.transaction.status,
+					code: `${r.transaction.status_detail}`
+				},
+				payments: {
+					current: {},
+					history: []
+				},
+				uid: transaction.id,
+				responseRaw: r.transaction,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status
+				}
+			};
+		},
+		refund: async () => {
+			return {};
+		},
+		methods
+	};
+};
+function resolveBaseUrl(mode) {
+	return mode === "production" ? "https://api-m.paypal.com" : "https://api-m.sandbox.paypal.com";
+}
+function createBasicAuthorization(credentials) {
+	return Buffer.from(`${credentials.clientId}:${credentials.clientSecret}`).toString("base64");
+}
+function normalizeMoney(value) {
+	const amount = Number(value);
+	if (!Number.isFinite(amount)) return "0.00";
+	return amount.toFixed(2);
+}
+function resolveCurrency(transaction, options) {
+	return `${options?.currency || transaction?.checkout?.billingInfo?.currency || transaction?.checkout?.shippingInfo?.currency || "USD"}`.toUpperCase();
+}
+function buildOrderBody(uid, transaction, options = {}, currencyCode) {
+	const amount = normalizeMoney(transaction?.checkout?.total || 0);
+	const intent = options.intent || "CAPTURE";
+	const application_context = {};
+	const queryParams = `?uid=${uid}&intent=${intent}&provider=${options.provider || "paypal"}`;
+	if (options.returnUrl) application_context.return_url = options.returnUrl + queryParams;
+	if (options.cancelUrl) application_context.cancel_url = options.cancelUrl + queryParams;
+	if (options.brandName) application_context.brand_name = options.brandName;
+	if (options.locale) application_context.locale = options.locale;
+	if (options.landingPage) application_context.landing_page = options.landingPage;
+	if (options.userAction) application_context.user_action = options.userAction;
+	const body = {
+		intent,
+		purchase_units: [{
+			reference_id: String(uid),
+			description: transaction?.description || void 0,
+			amount: {
+				currency_code: currencyCode,
+				value: amount
+			}
+		}]
+	};
+	if (Object.keys(application_context).length) body.application_context = application_context;
+	return body;
+}
+function extractApproveUrl(order) {
+	return (order?.links || []).find((link) => link?.rel === "approve")?.href;
+}
+const orderCodes = {
+	CREATED: {
+		status: "created",
+		messages: { es: "Orden creada" }
+	},
+	SAVED: {
+		status: "created",
+		messages: { es: "Orden guardada" }
+	},
+	APPROVED: {
+		status: "pending",
+		messages: { es: "Orden aprobada por el comprador" }
+	},
+	PAYER_ACTION_REQUIRED: {
+		status: "pending",
+		messages: { es: "Se requiere accion del comprador" }
+	},
+	COMPLETED: {
+		status: "success",
+		messages: { es: "Orden completada" }
+	},
+	VOIDED: {
+		status: "failure",
+		messages: { es: "Orden anulada" }
+	},
+	CANCELLED: {
+		status: "failure",
+		messages: { es: "Orden cancelada" }
+	},
+	PENDING: {
+		status: "pending",
+		messages: { es: "Orden pendiente" }
+	}
+};
+const captureCodes = {
+	COMPLETED: {
+		status: "success",
+		messages: { es: "Pago capturado" }
+	},
+	PARTIALLY_REFUNDED: {
+		status: "refund",
+		messages: { es: "Pago parcialmente reversado" }
+	},
+	REFUNDED: {
+		status: "refund",
+		messages: { es: "Pago reversado" }
+	},
+	PENDING: {
+		status: "pending",
+		messages: { es: "Pago pendiente" }
+	},
+	DECLINED: {
+		status: "failure",
+		messages: { es: "Pago rechazado" }
+	},
+	FAILED: {
+		status: "failure",
+		messages: { es: "Pago fallido" }
+	}
+};
+const refundCodes = {
+	COMPLETED: {
+		status: "refund",
+		messages: { es: "Reverso completado" }
+	},
+	PENDING: {
+		status: "pending",
+		messages: { es: "Reverso pendiente" }
+	},
+	FAILED: {
+		status: "failure",
+		messages: { es: "Reverso fallido" }
+	},
+	CANCELLED: {
+		status: "failure",
+		messages: { es: "Reverso cancelado" }
+	}
+};
+function handlePayPalStatus(status, kind = "order") {
+	const normalized = `${status || ""}`.toUpperCase();
+	const details = (kind === "capture" ? captureCodes : kind === "refund" ? refundCodes : orderCodes)[normalized];
+	if (!details) return {
+		status: "pending",
+		code: normalized || "UNKNOWN",
+		description: "Unknown PayPal status",
+		messages: { es: "Estado desconocido de PayPal" }
+	};
+	return {
+		...details,
+		code: normalized,
+		description: `PayPal status ${normalized}`
+	};
+}
+const createPayPal = (options) => {
+	const baseURL = resolveBaseUrl(options.mode);
+	const api = ofetch.create({ baseURL });
+	const getAccessToken = async () => {
+		const response = await api("/v1/oauth2/token", {
+			method: "POST",
+			body: "grant_type=client_credentials",
+			headers: {
+				"Authorization": `Basic ${createBasicAuthorization(options.credentials)}`,
+				"Content-Type": "application/x-www-form-urlencoded"
+			}
+		});
+		if (!response?.access_token) throw new Error("PayPal access token not received");
+		return response.access_token;
+	};
+	const request = async (url, opts = {}) => {
+		const accessToken = await getAccessToken();
+		return await api(url, {
+			...opts,
+			headers: {
+				...opts.headers || {},
+				Authorization: `Bearer ${accessToken}`
+			}
+		}).catch((err) => {
+			console.error("error", err.response.data || err.response?._data);
+			throw err;
+		});
+	};
+	const methods = {
+		getAccessToken,
+		createOrder: (body) => request("/v2/checkout/orders", {
+			method: "POST",
+			body,
+			headers: { Prefer: "return=representation" }
+		}),
+		captureOrder: (orderId, body = {}) => request(`/v2/checkout/orders/${orderId}/capture`, {
+			method: "POST",
+			body,
+			headers: { Prefer: "return=representation" }
+		}),
+		getOrder: (orderId) => request(`/v2/checkout/orders/${orderId}`, { method: "GET" }),
+		getCapture: (captureId) => request(`/v2/payments/captures/${captureId}`, { method: "GET" }),
+		refundCapture: (captureId, body = {}) => request(`/v2/payments/captures/${captureId}/refund`, {
+			method: "POST",
+			body,
+			headers: { Prefer: "return=representation" }
+		})
+	};
+	return {
+		methods,
+		prepare: async (uid, transaction, prepareOptions = {}) => {
+			const body = buildOrderBody(uid, transaction, prepareOptions, resolveCurrency(transaction, prepareOptions));
+			const order = await methods.createOrder(body);
+			const approveUrl = extractApproveUrl(order);
+			return {
+				id: order.id,
+				iframe: {
+					approveUrl,
+					orderId: order.id,
+					status: order.status,
+					links: order.links || []
+				},
+				extras: {
+					orderId: order.id,
+					approveUrl
+				}
+			};
+		},
+		sendPay: async (params, { transaction }) => {
+			console.log(params);
+			const orderId = `${params?.orderID || params?.orderId || params?.id || transaction.ref || ""}`;
+			if (!orderId) throw new Error("PayPal order id is required to capture payment");
+			const captureResult = await methods.captureOrder(orderId, params?.captureBody || {});
+			console.log("captureResult", captureResult, orderId);
+			const captures = captureResult?.purchase_units?.flatMap((unit) => unit?.payments?.captures || []) || [];
+			const currentCapture = captures[captures.length - 1] || captureResult;
+			const details = handlePayPalStatus(currentCapture?.status || captureResult?.status, "capture");
+			return {
+				id: currentCapture?.id || orderId,
+				uid: params.uid,
+				status: details.status,
+				body: captureResult,
+				message: details.messages.es
+			};
+		},
+		verify: async ({ uid, transaction }) => {
+			let responseRaw;
+			let kind = "capture";
+			try {
+				responseRaw = await methods.getCapture(transaction.ref);
+			} catch {
+				kind = "order";
+				responseRaw = await methods.getOrder(transaction.ref);
+			}
+			const captures = kind === "order" ? responseRaw?.purchase_units?.flatMap((unit) => unit?.payments?.captures || []) || [] : [responseRaw];
+			const current = captures[captures.length - 1] || responseRaw;
+			const statusDetails = handlePayPalStatus(current?.status || responseRaw?.status, captures.length ? "capture" : "order");
+			return {
+				id: current?.id || responseRaw?.id || transaction.ref,
+				status: statusDetails.status,
+				details: statusDetails,
+				customer: responseRaw?.payer || transaction?.session?.customer || {},
+				payments: {
+					current,
+					history: captures.length ? captures : [responseRaw],
+					refunds: current?.status === "REFUNDED" || current?.status === "PARTIALLY_REFUNDED" ? [current] : []
+				},
+				responseRaw,
+				uid,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status
+				}
+			};
+		},
+		refund: async (ref, amount, options = {}) => {
+			const payload = {};
+			const numericAmount = Number(options?.amount || amount);
+			if (numericAmount > 0) payload.amount = {
+				value: normalizeMoney(numericAmount),
+				currency_code: `${options?.currency || "USD"}`.toUpperCase()
+			};
+			if (options?.noteToPayer) payload.note_to_payer = options.noteToPayer;
+			const refundResult = await methods.refundCapture(ref, payload);
+			const details = handlePayPalStatus(refundResult?.status, "refund");
+			return {
+				...refundResult,
+				status: details.status,
+				details
+			};
+		}
+	};
+};
+const codes$1 = {
+	APPROVED: {
+		status: "success",
+		messages: { es: "Transacción aprobada" }
+	},
+	APPROVED_PARTIAL: {
+		status: "success",
+		messages: { es: "Transacción aprobada parcialmente" }
+	},
+	FAILED: {
+		status: "failure",
+		messages: { es: "Transacción rechazada" }
+	},
+	PARTIAL_EXPIRED: {
+		status: "failure",
+		messages: { es: "Sesión de transacción expirada" }
+	},
+	PENDING: {
+		status: "pending",
+		messages: { es: "Transacción pendiente" }
+	},
+	PENDING_VALIDATION: {
+		status: "pending",
+		messages: { es: "Transacción pendiente de validación" }
+	},
+	REFUNDED: {
+		status: "refund",
+		messages: { es: "Transacción reversada" }
+	},
+	REJECTED: {
+		status: "failure",
+		messages: { es: "Transacción rechazada" }
+	},
+	OK: {
+		status: "pending",
+		messages: { es: "Transacción pendiente" }
+	}
+};
+function handleControlCodes(body, lastPayment) {
+	const current = lastPayment;
+	const code = codes$1[current?.status || body.status];
+	if (!code) return {
+		status: "pending",
+		code: current?.reason || body.reason,
+		description: "unknow code",
+		messages: { es: "Codigo desconocido" }
+	};
+	return {
+		...code,
+		code: current?.reason || body.reason,
+		description: current?.message || body.message
+	};
+}
+function verifySignatureV1(secretKey) {
+	return (payload) => {
+		const { signature, internalReference, status } = payload;
+		const base = `${internalReference || payload.requestId}${status.status}${status.date}${secretKey}`;
+		return signature === crypto.createHash("sha1").update(base).digest("hex");
+	};
+}
+function createSession(secretKey, login, expiration) {
+	return () => {
+		const seed = dayjs().format();
+		const nonce = crypto.randomBytes(16).toString("hex");
+		const nonce64 = Buffer.from(nonce).toString("base64");
+		const tranKey = `${nonce}${seed}${secretKey}`;
+		return {
+			auth: {
+				login,
+				seed,
+				nonce: nonce64,
+				tranKey: crypto.createHash("sha1").update(tranKey).digest("base64")
+			},
+			expiration: dayjs().add(expiration, "minutes").format()
+		};
+	};
+}
+const createPlaceToPay = (options) => {
+	const { credentials, endpoint, urlReturn } = options;
+	const getSession = createSession(credentials.secretKey, credentials.login, 15);
+	return {
+		prepare: async (uid, transaction, options) => {
+			const baseSession = getSession();
+			const { checkout, session, ip, extras } = transaction;
+			const buyer = {
+				documentType: session.customer.documentType || "CI",
+				name: session.customer.givenName,
+				surname: session.customer.surname,
+				document: session.identification,
+				email: session.email,
+				mobile: session.customer.phone
+			};
+			const returnUrl = `${urlReturn}?uid=${uid}&provider=ptp&${Object.entries(options?.params || {}).map(([key, value]) => `${key}=${value}`).join("&")}`;
+			const type = options.params?.type === "subscription" ? "subscription" : "payment";
+			const body = {
+				...baseSession,
+				buyer,
+				returnUrl,
+				ipAddress: ip,
+				userAgent: "eMonkey Sandbox"
+			};
+			if (type === "payment") {
+				const baseIVA = checkout.taxes.find((el) => el.code === "4")?.base || 0;
+				const taxIVA = checkout.taxes.find((el) => el.code === "4")?.value || 0;
+				body.payment = {
+					reference: uid,
+					description: transaction.description || "Compra comercio electronico",
+					amount: {
+						currency: "USD",
+						total: checkout.total,
+						taxes: [{
+							kind: "valueAddedTax",
+							amount: taxIVA,
+							base: baseIVA
+						}]
+					}
+				};
+			}
+			if (type === "subscription") {
+				body.subscription = {
+					reference: uid,
+					description: transaction.description || "Suscripción comercio electronico"
+				};
+				body.skipResult = true;
+			}
+			let theEndpoint = `${endpoint}/api/session`;
+			if (extras?.instrument) {
+				body.instrument = extras.instrument;
+				body.payment.reference = extras?.reference || uid;
+				body.payer = body.buyer;
+				theEndpoint = `${endpoint}/api/collect`;
+			}
+			const r = await ofetch(theEndpoint, {
+				method: "POST",
+				body
+			}).catch((err) => {
+				console.error(err);
+				throw err;
+			});
+			let responsePay;
+			if (extras?.instrument) {
+				const details = handleControlCodes(r.status, void 0);
+				responsePay = {
+					id: transaction.ref,
+					uid,
+					status: details.status,
+					body: r,
+					message: details.messages.es,
+					sonda: true
+				};
+			}
+			return {
+				id: r.requestId,
+				...r,
+				responsePay,
+				sonda: true
+			};
+		},
+		sendPay: async ({ uid }, { transaction }) => {
+			const { auth } = getSession();
+			const body = { auth };
+			const r = await ofetch(`${endpoint}/api/session/${transaction.ref}`, {
+				method: "POST",
+				body
+			});
+			const details = handleControlCodes(r.status, void 0);
+			return {
+				id: transaction.ref,
+				uid,
+				status: details.status,
+				body: r,
+				message: details.messages.es,
+				sonda: true
+			};
+		},
+		verify: async ({ transaction, override }) => {
+			const { auth } = getSession();
+			const body = { auth };
+			const r = await ofetch(`${endpoint}/api/session/${transaction.ref}`, {
+				method: "POST",
+				body
+			});
+			const expiration = r.request.expiration;
+			if (dayjs(expiration).diff(dayjs().format()) < 0) override = true;
+			const history = r.payment || [];
+			const current = history?.[0];
+			const details = handleControlCodes(r.status, override ? current?.status : void 0);
+			return {
+				id: transaction.ref,
+				status: details.status,
+				details,
+				customer: r.request?.buyer,
+				payments: {
+					current,
+					history
+				},
+				responseRaw: r,
+				uid: transaction.id,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status
+				}
+			};
+		},
+		refund: async (ref, amount, opts) => {
+			const _amount = opts?.amount || 0;
+			const { auth } = getSession();
+			const body = { auth };
+			const { internalReference } = ((await ofetch(`${endpoint}/api/session/${ref}`, {
+				method: "POST",
+				body
+			})).payment || [])?.[0];
+			const totalAmount = _amount && _amount < amount ? _amount : amount;
+			console.log("Refunding", {
+				ref,
+				amount: totalAmount,
+				internalReference
+			});
+			return { ...await ofetch(`${endpoint}/api/reverse`, {
+				method: "POST",
+				body: {
+					auth,
+					internalReference,
+					amount: totalAmount
+				}
+			}) };
+		},
+		webhook: async (body) => {
+			if (!verifySignatureV1(credentials.secretKey)(body)) return false;
+			return { status: handleControlCodes(body.status).status };
+		},
+		methods: {
+			subscription: () => {},
+			deleteToken: (body) => {
+				const { auth } = getSession();
+				return ofetch(`${endpoint}/api/instrument/invalidate`, {
+					method: "POST",
+					body: {
+						auth,
+						...body
+					}
+				});
+			}
+		}
+	};
+};
+const createTransference = () => {
+	return {
+		methods: {},
+		prepare: async (uid, transaction) => {
+			const r = { id: Date.now() };
+			return {
+				id: transaction.id,
+				...r
+			};
+		},
+		sendPay: async ({ uid }, { transaction }) => {
+			return {
+				id: transaction.ref,
+				uid,
+				status: "success",
+				body: {},
+				message: ""
+			};
+		},
+		verify: async ({ uid, transaction }) => {
+			return {
+				id: transaction.id,
+				status: transaction.status,
+				details: {
+					messages: { es: "Orden creada" },
+					status: "success"
+				},
+				payments: {
+					current: {},
+					history: []
+				},
+				responseRaw: {},
+				uid,
+				customer: transaction.session.customer,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status
+				}
+			};
+		},
+		refund: async () => {
+			return {};
+		}
+	};
+};
+const codes = {
+	Pending: {
+		status: "pending",
+		messages: { es: "La orden se encuentra a la espera del pago" }
+	},
+	Paid: {
+		status: "success",
+		messages: { es: " Orden confirmada con pago recibido" }
+	},
+	Completed: {
+		status: "success",
+		messages: { es: " Orden confirmada con pago completado" }
+	},
+	Cancelling: {
+		status: "failure",
+		messages: { es: "Pago en estado cancelado por procesos internos o a solicitud" }
+	},
+	Refund: {
+		status: "refund",
+		messages: { es: "Pago anulado" }
+	}
+};
+function normalizeStatus(data) {
+	const code = codes[data.order_payments[0].payment_status];
+	if (!code) return {
+		status: "pending",
+		code: "??",
+		description: "unknow code",
+		messages: { es: "Codigo desconocido" }
+	};
+	return {
+		...code,
+		description: code.messages.es,
+		code: code.code || "??"
+	};
+}
+const createWabi = (opts) => {
+	const { credentials, endpoint } = opts;
+	const api = ofetch.create({ baseURL: endpoint });
+	const getAuth = async () => {
+		return await api("/generateToken", {
+			method: "POST",
+			body: credentials
+		});
+	};
+	return {
+		methods: {},
+		prepare: async (uid, { checkout, session }) => {
+			const { token } = await getAuth();
+			if (!token) throw new Error("No se pudo obtener el token de autenticación");
+			const r = await api("/create", {
+				method: "POST",
+				body: {
+					agency_id: opts.agency,
+					plattform_id: opts.platform,
+					latitude: "",
+					longitude: "",
+					ip_mac: "",
+					type_transaction: "1",
+					user_id: opts.userId || "",
+					amount: {
+						currency: "Bs",
+						value: Number(checkout.total)
+					},
+					payment_method: { type: "QR" },
+					order_payments: [{
+						description: checkout.items[0].title || "DEPOSITO BOLIVIANOS",
+						service_code: opts.serviceCode,
+						debtor_first_name: session.customer.givenName,
+						debtor_last_name: session.customer.surname,
+						debtor_phone: session.customer.phone || "",
+						debtor_ci_code: session.identification,
+						invoice_name: "",
+						invoice_type: "",
+						invoice_document_number: "",
+						additional_data: opts.callbackUrl ? `{"callbackUrl":"${opts.callbackUrl}"}` : void 0,
+						amount: {
+							currency: "Bs",
+							value: Number(checkout.total)
+						},
+						items: checkout.items.map((item) => {
+							return {
+								description: item.title,
+								unit_price: item.item.unitAmount,
+								cuf: "",
+								invoice_number: "",
+								type: "1",
+								additional_data: {},
+								additional_billable: {}
+							};
+						})
+					}],
+					customer_payer: {
+						first_name: session.customer.givenName,
+						last_name: session.customer.surname,
+						email: session.email,
+						phone: session.customer.phone || "",
+						document: {
+							document_type: "",
+							business_name: "",
+							document_number: ""
+						}
+					}
+				},
+				headers: { Authorization: `Bearer ${token}` }
+			}).catch((e) => {
+				console.error("Error al crear el QR:", e);
+				throw e;
+			});
+			if (!r) throw new Error("No se recibió respuesta del proveedor Wabi");
+			return {
+				...r,
+				extras: r.order_payments?.[0] || {},
+				sonda: dayjs().add(1, "day").valueOf()
+			};
+		},
+		sendPay: async ({ uid }, { transaction }) => {
+			const { token } = await getAuth();
+			const r = await api(`/status/${transaction.ref}`, {
+				method: "GET",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+			const details = normalizeStatus(r);
+			return {
+				id: transaction.ref,
+				uid,
+				status: details.status,
+				body: r,
+				message: details.description || details.messages?.es || "",
+				sonda: details.status !== "success" ? dayjs().add(1, "day").valueOf() : false
+			};
+		},
+		verify: async ({ transaction }) => {
+			const { token } = await getAuth();
+			const r = await api(`/status/${transaction.ref}`, {
+				method: "GET",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+			const details = normalizeStatus(r);
+			return {
+				id: transaction.ref,
+				status: details.status,
+				responseRaw: r,
+				details,
+				customer: transaction.session.customer || {},
+				payments: {
+					current: {},
+					history: []
+				},
+				uid: transaction.id,
+				transaction: {
+					provider: transaction.provider,
+					status: transaction.status,
+					responseTasks: transaction.responseTasks,
+					payloadTasks: { success: transaction.tasks.success?.map((el) => {
+						return el.payload;
+					}) }
+				}
+			};
+		},
+		refund: async () => {
+			return {};
+		}
+	};
+};
+function createGraphql(db) {
+	return {
+		stores: { findByPk: async (id) => {
+			return await db.query.stores.findFirst({ where: { id } });
+		} },
+		checkout: {
+			create: async (data) => {
+				return (await db.insert(checkouts).values(data).returning())[0];
+			},
+			findByPk: async (id) => {
+				return await db.query.checkouts.findFirst({ where: { id } });
+			},
+			updateByPk: async (id, data) => {
+				return (await db.update(checkouts).set(data).where(eq(checkouts.id, id)).returning())[0];
+			}
+		},
+		session: { create: async (data) => {
+			return (await db.insert(sessions).values(data).returning())[0];
+		} },
+		transaction: {
+			create: async (data) => {
+				const items = await db.insert(transactions).values(data).returning({ id: transactions.id });
+				return await db.query.transactions.findFirst({
+					where: { id: items[0].id },
+					with: {
+						checkout: true,
+						session: { with: { store: { columns: {
+							id: true,
+							name: true,
+							endpoint: true
+						} } } }
+					}
+				});
+			},
+			findByPk: async (id) => {
+				return await db.query.transactions.findFirst({
+					where: { id },
+					with: {
+						checkout: true,
+						session: { with: { store: { columns: {
+							id: true,
+							name: true,
+							endpoint: true
+						} } } }
+					}
+				});
+			},
+			updateByPk: async (id, data) => {
+				return (await db.update(transactions).set(data).where(eq(transactions.id, id)).returning())[0];
+			}
+		},
+		refunds: { create: async (data) => {
+			return (await db.insert(refunds).values(data).returning())[0];
+		} }
+	};
+}
+export { CustomError, createBancoEconomico, createBancoGanadero, createCybersource, createDatafast, createGraphql, createMultipagos, createPagomedios, createPayPal, createPayment, createPaymentez, createPlaceToPay, createTransference, createWabi, useTasks };