@agent-cards/sdk 0.23.28 → 0.24.1

package/dist/vtex-payments.generated.d.ts

@@ -0,0 +1,127 @@
+declare var VTEX_PAYMENTS_PSP: string;
+declare var VTEX_PAYMENTS_CAPABILITY: string;
+declare var VTEX_PAYMENTS_OPERATION: string;
+declare var VTEX_PAYMENTS_FALLBACK_HOST: string;
+declare var VTEX_PAYMENTS_PREPARATION_URL: string;
+declare var VTEX_PAYMENTS_REFUSAL_CODES: readonly string[];
+declare var VTEX_PAYMENTS_LINE_KEYS: readonly string[];
+declare var VTEX_PAYMENTS_FIELD_KEYS: readonly string[];
+declare var VTEX_PAYMENTS_ADDRESS_KEYS: readonly string[];
+declare var VTEX_PAYMENTS_NETWORKS: Readonly<{
+    1: "amex";
+    2: "visa";
+    4: "mastercard";
+    5: "discover";
+}>;
+declare var VTEX_PAYMENTS_MERCHANT_PINS: readonly (Readonly<{
+    account: "alssports";
+    origin: "https://www.als.com";
+    merchant: "Al's Sporting Goods";
+    currency: "USD";
+}> | Readonly<{
+    account: "roadrunnersports";
+    origin: "https://www.roadrunnersports.com";
+    merchant: "Road Runner Sports";
+    currency: "USD";
+}>)[];
+declare function vtexPaymentsCardTarget(url: any): Readonly<{
+    account: string | null;
+    transactionId: string;
+    orderId: string | null;
+    fallback: boolean;
+}> | null;
+declare function isVtexPaymentsCardUrl(url: any): boolean;
+declare function vtexPaymentsBodyVerdict(body: any, target: any): Readonly<{
+    verdict: "refuse";
+    code: any;
+}> | Readonly<{
+    verdict: "card";
+}>;
+declare function vtexPaymentsRequestRefusal(request: any): any;
+declare function isPreparedVtexPaymentsRequest(url: any, method: any, body: any, environment: any, headers: any): boolean;
+declare function vtexPaymentsOriginPin(merchantOrigin: any, pins?: readonly (Readonly<{
+    account: "alssports";
+    origin: "https://www.als.com";
+    merchant: "Al's Sporting Goods";
+    currency: "USD";
+}> | Readonly<{
+    account: "roadrunnersports";
+    origin: "https://www.roadrunnersports.com";
+    merchant: "Road Runner Sports";
+    currency: "USD";
+}>)[]): Readonly<{
+    account: "alssports";
+    origin: "https://www.als.com";
+    merchant: "Al's Sporting Goods";
+    currency: "USD";
+}> | Readonly<{
+    account: "roadrunnersports";
+    origin: "https://www.roadrunnersports.com";
+    merchant: "Road Runner Sports";
+    currency: "USD";
+}> | null;
+declare function vtexPaymentsAccountPin(account: any, pins?: readonly (Readonly<{
+    account: "alssports";
+    origin: "https://www.als.com";
+    merchant: "Al's Sporting Goods";
+    currency: "USD";
+}> | Readonly<{
+    account: "roadrunnersports";
+    origin: "https://www.roadrunnersports.com";
+    merchant: "Road Runner Sports";
+    currency: "USD";
+}>)[]): Readonly<{
+    account: "alssports";
+    origin: "https://www.als.com";
+    merchant: "Al's Sporting Goods";
+    currency: "USD";
+}> | Readonly<{
+    account: "roadrunnersports";
+    origin: "https://www.roadrunnersports.com";
+    merchant: "Road Runner Sports";
+    currency: "USD";
+}> | null;
+declare function vtexPaymentsMerchantRefusal(merchantOrigin: any, request: any, pins?: readonly (Readonly<{
+    account: "alssports";
+    origin: "https://www.als.com";
+    merchant: "Al's Sporting Goods";
+    currency: "USD";
+}> | Readonly<{
+    account: "roadrunnersports";
+    origin: "https://www.roadrunnersports.com";
+    merchant: "Road Runner Sports";
+    currency: "USD";
+}>)[]): "vtex_payments_merchant_unreviewed" | null;
+declare function vtexPaymentsAmount(body: any): {
+    amountCents: any;
+    currency: any;
+} | null;
+declare function vtexPaymentsRefusalMessage(code: any): any;
+declare function vtexPaymentsDeviceRefusal(request: any): any;
+declare function injectVtexPaymentsCard(body: any, card: any): {
+    body: string;
+    where: string[];
+};
+declare function vtexPaymentsRefusalCode(text: any): string | null;
+declare function vtexPaymentsAnswerOutcome(status: any, text: any): {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+    body?: undefined;
+    pending?: undefined;
+} | {
+    outcome: string;
+    code: string;
+    reason?: undefined;
+    body?: undefined;
+    pending?: undefined;
+} | {
+    outcome: string;
+    body: string;
+    pending: string;
+    reason?: undefined;
+    code?: undefined;
+};
+declare var vtex_payments_default: any;
+declare var device: any;
+export { VTEX_PAYMENTS_ADDRESS_KEYS, VTEX_PAYMENTS_CAPABILITY, VTEX_PAYMENTS_FALLBACK_HOST, VTEX_PAYMENTS_FIELD_KEYS, VTEX_PAYMENTS_LINE_KEYS, VTEX_PAYMENTS_MERCHANT_PINS, VTEX_PAYMENTS_NETWORKS, VTEX_PAYMENTS_OPERATION, VTEX_PAYMENTS_PREPARATION_URL, VTEX_PAYMENTS_PSP, VTEX_PAYMENTS_REFUSAL_CODES, vtex_payments_default as default, device, injectVtexPaymentsCard, isPreparedVtexPaymentsRequest, isVtexPaymentsCardUrl, vtexPaymentsAccountPin, vtexPaymentsAmount, vtexPaymentsAnswerOutcome, vtexPaymentsBodyVerdict, vtexPaymentsCardTarget, vtexPaymentsDeviceRefusal, vtexPaymentsMerchantRefusal, vtexPaymentsOriginPin, vtexPaymentsRefusalCode, vtexPaymentsRefusalMessage, vtexPaymentsRequestRefusal };

package/dist/vtex-payments.generated.js

@@ -0,0 +1,544 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: 07dfa13862b2c6a1a9256394c968c0a364e25eb763d8dee500aaed4f0fe259a7
+// src/deep-freeze.js
+function deepFreeze(value) {
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+// src/registration.js
+var PARTS = {
+    psp: "id",
+    definitions: "list",
+    refusedOperations: "list",
+    settlementReadback: "any",
+    exactUrl: "rule",
+    bodyGate: "rule",
+    amount: "rule",
+    hostedEntry: "rule",
+    limitations: "sentences"
+};
+var DEVICE_PARTS = { psp: "id", testPans: "numbers", deviceCheck: "rule", fill: "rule", refusalCode: "rule", outcome: "rule", relayOnly: "flag" };
+var PSP_ID = /^[a-z][a-z0-9_]*$/;
+function problemsOf(spec, parts) {
+    if (!spec || typeof spec !== "object")
+        return ["a registration is an object"];
+    const psp = spec.psp;
+    if (typeof psp !== "string" || !PSP_ID.test(psp))
+        return [`${JSON.stringify(psp)} is not a processor id`];
+    const problems = Object.keys(spec).filter((key) => !(key in parts)).map((key) => `${psp}: ${key} is no registration part`);
+    for (const [key, kind] of Object.entries(parts)) {
+        const value = spec[key];
+        if (value === void 0)
+            continue;
+        if (kind === "rule" && typeof value !== "function")
+            problems.push(`${psp}: ${key} is not a function`);
+        if (kind === "flag" && value !== true)
+            problems.push(`${psp}: ${key} is not true`);
+        if (kind === "numbers" && !((Array.isArray(value) || value instanceof Set) && [...value].every((n) => typeof n === "string" && /^\d{12,19}$/.test(n)))) {
+            problems.push(`${psp}: ${key} is not a list of card numbers`);
+        }
+        if (kind === "sentences" && !(Array.isArray(value) && value.length > 0 && value.every((s) => typeof s === "string" && s.trim() !== ""))) {
+            problems.push(`${psp}: ${key} is not a list of sentences`);
+        }
+    }
+    if ("definitions" in parts) {
+        if (!Array.isArray(spec.definitions) || spec.definitions.length === 0)
+            problems.push(`${psp}: names no definition`);
+        else if (spec.definitions.some((definition) => definition?.psp !== psp))
+            problems.push(`${psp}: a definition names another processor`);
+        for (const id of spec.refusedOperations ?? []) {
+            if (typeof id !== "string" || !id.startsWith(`${psp}.`))
+                problems.push(`${psp}: ${JSON.stringify(id)} is not one of its operations`);
+        }
+        const pages = Array.isArray(spec.definitions) ? spec.definitions.filter((d) => d?.hostedForm?.cardIn === "processor_page") : [];
+        if (spec.hostedEntry !== void 0 && (pages.length === 0 || pages.some((d) => d.hostedForm.policy !== void 0))) {
+            problems.push(`${psp}: hostedEntry needs a definition whose hosted form takes the card on the processor's page and names no policy`);
+        }
+    }
+    return problems;
+}
+function registered(spec, parts) {
+    const problems = problemsOf(spec, parts);
+    if (problems.length)
+        throw new Error(`payment-core registration refused: ${problems.join("; ")}`);
+    return deepFreeze({ ...spec });
+}
+function registerProcessor(spec) {
+    return registered(spec, PARTS);
+}
+function registerDeviceRules(psp, rules) {
+    const checked = registered({ psp, ...rules }, DEVICE_PARTS);
+    return checked.testPans ? Object.freeze({ ...checked, testPans: new Set(checked.testPans) }) : checked;
+}
+// src/processors/vtex_payments.js
+var VTEX_PAYMENTS_PSP = "vtex_payments";
+var VTEX_PAYMENTS_CAPABILITY = "vtex_payments_card_payment";
+var VTEX_PAYMENTS_OPERATION = "vtex_payments.card_request";
+var VTEX_PAYMENTS_FALLBACK_HOST = "api.vtexvault.com";
+var VTEX_PAYMENTS_PREPARATION_URL = "https://api.vtexvault.com/api/payments/transactions/prepared/payments";
+var VTEX_PAYMENTS_REFUSAL_CODES = /* @__PURE__ */ Object.freeze([
+    "vtex_payments_url_refused",
+    "vtex_payments_fallback_refused",
+    "vtex_payments_headers_refused",
+    "vtex_payments_saved_card",
+    "vtex_payments_split_payment",
+    "vtex_payments_installments",
+    "vtex_payments_body_unsupported"
+]);
+var VTEX_PAYMENTS_LINE_KEYS = /* @__PURE__ */ Object.freeze([
+    "currencyCode",
+    "paymentSystem",
+    "accountId",
+    "value",
+    "referenceValue",
+    "installments",
+    "installmentsInterestRate",
+    "installmentsValue",
+    "groupName",
+    "fields",
+    "transaction",
+    "id"
+]);
+var VTEX_PAYMENTS_FIELD_KEYS = /* @__PURE__ */ Object.freeze([
+    "address",
+    "accountId",
+    "validationCode",
+    "metadata",
+    "document",
+    "holderName",
+    "cardNumber",
+    "dueDate",
+    "deviceFingerprint",
+    "addressId"
+]);
+var VTEX_PAYMENTS_ADDRESS_KEYS = /* @__PURE__ */ Object.freeze([
+    "street",
+    "complement",
+    "number",
+    "city",
+    "reference",
+    "addressType",
+    "neighborhood",
+    "addressId",
+    "state",
+    "country",
+    "postalCode"
+]);
+var VTEX_PAYMENTS_NETWORKS = /* @__PURE__ */ Object.freeze({ 1: "amex", 2: "visa", 4: "mastercard", 5: "discover" });
+var VTEX_PAYMENTS_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
+    Object.freeze({ account: "alssports", origin: "https://www.als.com", merchant: "Al's Sporting Goods", currency: "USD" }),
+    Object.freeze({ account: "roadrunnersports", origin: "https://www.roadrunnersports.com", merchant: "Road Runner Sports", currency: "USD" })
+]);
+var BODY_LIMIT = 16384;
+var ACCOUNT_HOST = /^([a-z0-9]{1,63})\.vtexvault\.com$/;
+var PATH = /^\/api\/payments\/transactions\/([0-9A-Fa-f]{32})\/payments$/;
+var ORDER_GROUP = /^[0-9]{6,24}$/;
+var BASE64 = /^[A-Za-z0-9+/]{4,1020}={0,2}$/;
+var JSON_TYPE = /^application\/json(?:\s*;\s*charset=utf-8)?$/i;
+var CARD_NUMBER = /^[0-9]{12,19}$/;
+var SECURITY_CODE = /^[0-9]{3,4}$/;
+var DUE_DATE = /^(?:0[1-9]|1[0-2])\/[0-9]{2}$/;
+var CURRENCY = /^[A-Z]{3}$/;
+var TRANSACTION_ID = /^[0-9A-Fa-f]{32}$/;
+var MERCHANT_NAME = /^[A-Za-z0-9_.-]{1,64}$/;
+var SHORT_ID = /^[A-Za-z0-9_-]{1,64}$/;
+var FINGERPRINT = /^[A-Za-z0-9_.:=+/-]{1,256}$/;
+var TEXT = /^[^\u0000-\u001f\u007f]{1,200}$/;
+var CARD_DIGITS = /[0-9]{12,}/;
+var DEVICE_INFO_KEYS = Object.freeze(["sw", "sh", "cd", "tz", "lang", "java", "sourceApplication"]);
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var refuse = (code) => Object.freeze({ verdict: "refuse", code });
+var CARD = /* @__PURE__ */ Object.freeze({ verdict: "card" });
+var inOrder = (value, keys) => {
+    let at = 0;
+    for (const name of Object.keys(value)) {
+        while (at < keys.length && keys[at] !== name)
+            at += 1;
+        if (at === keys.length)
+            return false;
+        at += 1;
+    }
+    return true;
+};
+var cardDigits = (text) => CARD_DIGITS.test(text.replace(/[^0-9A-Za-z]/g, ""));
+var plainText = (value) => typeof value === "string" && TEXT.test(value) && !cardDigits(value);
+var count = (value) => Number.isSafeInteger(value) && value >= 0;
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64Text(input) {
+    if (input.length % 4 !== 0)
+        return null;
+    const stripped = input.replace(/={1,2}$/, "");
+    let out = "";
+    let bits = 0;
+    let value = 0;
+    for (const character of stripped) {
+        const sextet = BASE64_ALPHABET.indexOf(character);
+        if (sextet < 0)
+            return null;
+        value = value << 6 | sextet;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out += String.fromCharCode(value >> bits & 255);
+            value &= (1 << bits) - 1;
+        }
+    }
+    return out;
+}
+function deviceInfoSound(text) {
+    if (typeof text !== "string" || !BASE64.test(text))
+        return false;
+    const decoded = base64Text(text);
+    if (decoded === null)
+        return false;
+    let info;
+    try {
+        info = JSON.parse(decoded);
+    }
+    catch {
+        return false;
+    }
+    if (!record(info) || !Object.keys(info).every((key) => DEVICE_INFO_KEYS.includes(key)))
+        return false;
+    for (const key of ["sw", "sh", "cd"])
+        if (own(info, key) && !(count(info[key]) && info[key] <= 1e5))
+            return false;
+    if (own(info, "tz") && !(Number.isSafeInteger(info.tz) && Math.abs(info.tz) <= 1440))
+        return false;
+    if (own(info, "lang") && !(typeof info.lang === "string" && /^[A-Za-z]{0,8}$/.test(info.lang)))
+        return false;
+    if (own(info, "java") && typeof info.java !== "boolean")
+        return false;
+    return !own(info, "sourceApplication") || typeof info.sourceApplication === "string" && /^[A-Za-z0-9_.-]{1,32}$/.test(info.sourceApplication);
+}
+function vtexPaymentsCardTarget(url) {
+    if (typeof url !== "string" || url.length > 8192)
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.href !== url || parsed.protocol !== "https:" || parsed.port || parsed.username || parsed.password || parsed.hash)
+        return null;
+    const path = PATH.exec(parsed.pathname);
+    const host = ACCOUNT_HOST.exec(parsed.hostname);
+    if (!path || !host)
+        return null;
+    const fallback = parsed.hostname === VTEX_PAYMENTS_FALLBACK_HOST;
+    const names = [...parsed.searchParams.keys()];
+    const expected = ["orderId", "deviceInfo", ...parsed.searchParams.has("callbackUrl") ? ["callbackUrl"] : [], ...fallback ? ["an"] : []];
+    if (names.length !== expected.length || names.some((name, i) => name !== expected[i]))
+        return null;
+    const orderId = parsed.searchParams.get("orderId");
+    if (!ORDER_GROUP.test(orderId) || !deviceInfoSound(parsed.searchParams.get("deviceInfo")))
+        return null;
+    if (parsed.searchParams.has("callbackUrl")) {
+        let callback;
+        try {
+            callback = new URL(parsed.searchParams.get("callbackUrl"));
+        }
+        catch {
+            return null;
+        }
+        if (callback.protocol !== "https:" || callback.username || callback.password || callback.searchParams.get("step") !== "payment" || callback.searchParams.get("og") !== orderId)
+            return null;
+    }
+    const account = fallback ? parsed.searchParams.get("an") : host[1];
+    if (!/^[a-z0-9]{1,63}$/.test(account) || account === "api")
+        return null;
+    return Object.freeze({ account, transactionId: path[1], orderId, fallback });
+}
+function isVtexPaymentsCardUrl(url) {
+    const target = vtexPaymentsCardTarget(url);
+    return target !== null && !target.fallback;
+}
+function readBody(body) {
+    if (typeof body !== "string" || body === "" || body.length > BODY_LIMIT)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(body);
+        if (!Array.isArray(value) || JSON.stringify(value) !== body)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return value;
+}
+function cardLine(line) {
+    if (!record(line))
+        return false;
+    const fields = record(line.fields) ? line.fields : {};
+    return line.groupName === "creditCardPaymentGroup" || line.groupName === "debitCardPaymentGroup" || own(line, "accountId") || own(fields, "accountId") || own(fields, "cardNumber") || own(fields, "validationCode") || own(fields, "dueDate");
+}
+function addressSound(address) {
+    if (!record(address) || !inOrder(address, VTEX_PAYMENTS_ADDRESS_KEYS))
+        return false;
+    for (const [key, value] of Object.entries(address)) {
+        if (key === "addressType") {
+            if (value !== "billing")
+                return false;
+            continue;
+        }
+        if (key === "addressId") {
+            if (!(typeof value === "string" && SHORT_ID.test(value)))
+                return false;
+            continue;
+        }
+        if (value === null && (key === "complement" || key === "reference"))
+            continue;
+        if (!(value === "" || plainText(value)))
+            return false;
+    }
+    return true;
+}
+function fieldsSound(fields) {
+    if (!record(fields) || !inOrder(fields, VTEX_PAYMENTS_FIELD_KEYS) || own(fields, "metadata"))
+        return false;
+    if (!(typeof fields.cardNumber === "string" && CARD_NUMBER.test(fields.cardNumber)))
+        return false;
+    if (!(typeof fields.validationCode === "string" && SECURITY_CODE.test(fields.validationCode)))
+        return false;
+    if (!(typeof fields.dueDate === "string" && DUE_DATE.test(fields.dueDate)))
+        return false;
+    if (!plainText(fields.holderName))
+        return false;
+    if (own(fields, "document") && !(fields.document === "" || plainText(fields.document) && fields.document.length <= 32))
+        return false;
+    if (own(fields, "address") && !addressSound(fields.address))
+        return false;
+    if (own(fields, "deviceFingerprint") && !(typeof fields.deviceFingerprint === "string" && FINGERPRINT.test(fields.deviceFingerprint)))
+        return false;
+    return !own(fields, "addressId") || typeof fields.addressId === "string" && SHORT_ID.test(fields.addressId);
+}
+function vtexPaymentsBodyVerdict(body, target) {
+    const lines = readBody(body);
+    if (lines === null || lines.length === 0 || !lines.every(record))
+        return refuse("vtex_payments_body_unsupported");
+    const cards = lines.filter(cardLine);
+    if (cards.some((line2) => own(line2, "accountId") || own(line2.fields ?? {}, "accountId")))
+        return refuse("vtex_payments_saved_card");
+    if (cards.length === 0)
+        return refuse("vtex_payments_body_unsupported");
+    if (lines.length !== 1 || own(lines[0], "id"))
+        return refuse("vtex_payments_split_payment");
+    const line = lines[0];
+    if (!inOrder(line, VTEX_PAYMENTS_LINE_KEYS) || line.groupName !== "creditCardPaymentGroup")
+        return refuse("vtex_payments_body_unsupported");
+    if (!(typeof line.currencyCode === "string" && CURRENCY.test(line.currencyCode)) || !own(VTEX_PAYMENTS_NETWORKS, line.paymentSystem) || !Number.isSafeInteger(line.paymentSystem) || !(count(line.value) && line.value > 0))
+        return refuse("vtex_payments_body_unsupported");
+    if (line.installments !== 1 || line.referenceValue !== line.value || own(line, "installmentsInterestRate") && line.installmentsInterestRate !== 0 || own(line, "installmentsValue") && line.installmentsValue !== line.value)
+        return refuse("vtex_payments_installments");
+    const transaction = line.transaction;
+    if (!record(transaction) || Object.keys(transaction).join() !== "id,merchantName" || !(typeof transaction.id === "string" && TRANSACTION_ID.test(transaction.id)) || !(typeof transaction.merchantName === "string" && MERCHANT_NAME.test(transaction.merchantName)))
+        return refuse("vtex_payments_body_unsupported");
+    if (target && transaction.id.toUpperCase() !== target.transactionId.toUpperCase())
+        return refuse("vtex_payments_split_payment");
+    return fieldsSound(line.fields) ? CARD : refuse("vtex_payments_body_unsupported");
+}
+function headerValue(headers, name) {
+    const found = Object.keys(headers).filter((key) => key.toLowerCase() === name);
+    if (found.length === 0)
+        return void 0;
+    return found.length === 1 && typeof headers[found[0]] === "string" ? headers[found[0]] : null;
+}
+function vtexPaymentsRequestRefusal(request) {
+    if (!record(request) || typeof request.method !== "string" || request.method.toUpperCase() !== "POST")
+        return "vtex_payments_url_refused";
+    const target = vtexPaymentsCardTarget(request.url);
+    if (target === null)
+        return "vtex_payments_url_refused";
+    if (target.fallback)
+        return "vtex_payments_fallback_refused";
+    const headers = record(request.headers) ? request.headers : {};
+    const contentType = headerValue(headers, "content-type");
+    if (typeof contentType !== "string" || !JSON_TYPE.test(contentType.trim()) || Object.keys(headers).length !== new Set(Object.keys(headers).map((key) => key.toLowerCase())).size) {
+        return "vtex_payments_headers_refused";
+    }
+    const verdict = vtexPaymentsBodyVerdict(request.body, target);
+    return verdict.verdict === "card" ? null : verdict.code;
+}
+function isPreparedVtexPaymentsRequest(url, method, body, environment, headers) {
+    return environment === "production" && typeof method === "string" && method.toUpperCase() === "POST" && vtexPaymentsRequestRefusal({ url, method: "POST", headers: record(headers) ? headers : {}, body }) === null;
+}
+function vtexPaymentsOriginPin(merchantOrigin, pins = VTEX_PAYMENTS_MERCHANT_PINS) {
+    return typeof merchantOrigin === "string" ? pins.find((pin) => pin.origin === merchantOrigin) ?? null : null;
+}
+function vtexPaymentsAccountPin(account, pins = VTEX_PAYMENTS_MERCHANT_PINS) {
+    return typeof account === "string" ? pins.find((pin) => pin.account === account) ?? null : null;
+}
+function linePinned(body, pin) {
+    if (vtexPaymentsBodyVerdict(body).verdict !== "card")
+        return false;
+    const [line] = JSON.parse(body);
+    return line.currencyCode === pin.currency && line.transaction.merchantName.toLowerCase() === pin.account;
+}
+function callbackPinned(url, pin) {
+    let callback;
+    try {
+        const parsed = new URL(url);
+        if (!parsed.searchParams.has("callbackUrl"))
+            return true;
+        callback = new URL(parsed.searchParams.get("callbackUrl"));
+    }
+    catch {
+        return false;
+    }
+    return callback.origin === pin.origin;
+}
+function vtexPaymentsMerchantRefusal(merchantOrigin, request, pins = VTEX_PAYMENTS_MERCHANT_PINS) {
+    const pin = vtexPaymentsOriginPin(merchantOrigin, pins);
+    const target = record(request) ? vtexPaymentsCardTarget(request.url) : null;
+    return pin !== null && target !== null && !target.fallback && target.account === pin.account && linePinned(request.body, pin) && callbackPinned(request.url, pin) ? null : "vtex_payments_merchant_unreviewed";
+}
+function vtexPaymentsAmount(body) {
+    if (vtexPaymentsBodyVerdict(body).verdict !== "card")
+        return null;
+    const [line] = JSON.parse(body);
+    return { amountCents: line.value, currency: line.currencyCode.toLowerCase() };
+}
+var REFUSAL_MESSAGES = /* @__PURE__ */ Object.freeze({
+    vtex_payments_url_refused: "Refusing to pay: this VTEX card request does not go to the store's own VTEX payments address as the checkout sends it. Nothing was sent.",
+    vtex_payments_fallback_refused: "Refusing to pay: this VTEX card request is the checkout's resend to VTEX's shared host, which never takes the card. Nothing was sent.",
+    vtex_payments_headers_refused: "Refusing to pay: this VTEX card request does not carry the checkout's own headers. Nothing was sent.",
+    vtex_payments_saved_card: "Refusing to pay: this VTEX payment would charge a card the store keeps on file, not the card you chose. Nothing was sent.",
+    vtex_payments_split_payment: "Refusing to pay: this VTEX payment splits the price with a gift card, another card or another seller. Nothing was sent.",
+    vtex_payments_installments: "Refusing to pay: this VTEX payment is in installments or adds interest to the price. Nothing was sent.",
+    vtex_payments_body_unsupported: "Refusing to pay: this is not the card request of the store's VTEX checkout. Nothing was sent.",
+    vtex_payments_merchant_unreviewed: "Refusing to pay: this VTEX payment goes to a store Agentcard has not reviewed. Nothing was sent."
+});
+function vtexPaymentsRefusalMessage(code) {
+    return own(REFUSAL_MESSAGES, code) ? REFUSAL_MESSAGES[code] : REFUSAL_MESSAGES.vtex_payments_body_unsupported;
+}
+function vtexPaymentsDeviceRefusal(request) {
+    const refusal = vtexPaymentsRequestRefusal(request);
+    if (refusal)
+        return refusal;
+    const pin = vtexPaymentsAccountPin(vtexPaymentsCardTarget(request.url).account);
+    return pin !== null && linePinned(request.body, pin) && callbackPinned(request.url, pin) ? null : "vtex_payments_merchant_unreviewed";
+}
+var FILL_FAILED = "Could not fill the card fields for VTEX. Nothing was sent.";
+var cardText = (value) => typeof value === "string" ? value : Number.isSafeInteger(value) ? String(value) : "";
+var NETWORK_OF = Object.freeze({
+    visa: (number) => /^4[0-9]{12}(?:[0-9]{3}){0,2}$/.test(number),
+    mastercard: (number) => /^(?:5[1-5][0-9]{14}|2(?:2(?:2[1-9]|[3-9][0-9])|[3-6][0-9]{2}|7(?:[01][0-9]|20))[0-9]{12})$/.test(number),
+    amex: (number) => /^3[47][0-9]{13}$/.test(number),
+    discover: (number) => /^(?:6011[0-9]{12}|64[4-9][0-9]{13}|65[0-9]{14})$/.test(number)
+});
+var NETWORK_NAME = Object.freeze({ visa: "Visa", mastercard: "Mastercard", amex: "American Express", discover: "Discover" });
+var whole = (value) => {
+    if (Number.isSafeInteger(value) && value >= 0)
+        return value;
+    return typeof value === "string" && /^[0-9]{1,4}$/.test(value) ? Number(value) : NaN;
+};
+function injectVtexPaymentsCard(body, card) {
+    const verdict = vtexPaymentsBodyVerdict(body);
+    if (verdict.verdict !== "card")
+        throw new Error(vtexPaymentsRefusalMessage(verdict.code));
+    const number = card ? cardText(card.number) : "";
+    const cvc = card ? cardText(card.cvc) : "";
+    const month = card ? whole(card.month) : NaN;
+    const rawYear = card ? whole(card.year) : NaN;
+    const year = rawYear >= 2e3 && rawYear <= 2099 ? rawYear - 2e3 : rawYear;
+    if (!CARD_NUMBER.test(number) || !SECURITY_CODE.test(cvc) || !(month >= 1 && month <= 12) || !(year >= 0 && year <= 99))
+        throw new Error(FILL_FAILED);
+    const lines = JSON.parse(body);
+    const network = VTEX_PAYMENTS_NETWORKS[lines[0].paymentSystem];
+    if (!NETWORK_OF[network](number)) {
+        throw new Error(`Refusing to pay: the store's checkout routes this payment as ${NETWORK_NAME[network]}, and the card you chose is not one. Nothing was sent.`);
+    }
+    if (cvc.length !== (network === "amex" ? 4 : 3))
+        throw new Error(FILL_FAILED);
+    const fields = lines[0].fields;
+    fields.cardNumber = number;
+    fields.validationCode = cvc;
+    fields.dueDate = `${String(month).padStart(2, "0")}/${String(year).padStart(2, "0")}`;
+    const where = ["fields.cardNumber", "fields.validationCode", "fields.dueDate"];
+    const name = card && typeof card.name === "string" ? card.name.trim() : "";
+    if (name && plainText(name)) {
+        fields.holderName = name;
+        where.push("fields.holderName");
+    }
+    return { body: JSON.stringify(lines), where };
+}
+var ANSWER_LIMIT = 65536;
+var ERROR_CODE = /^[A-Za-z0-9_.-]{1,48}$/;
+function vtexPaymentsRefusalCode(text) {
+    if (typeof text !== "string" || text === "" || text.length > ANSWER_LIMIT)
+        return null;
+    let answer;
+    try {
+        answer = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const code = record(answer) && record(answer.error) ? answer.error.code : void 0;
+    return typeof code === "string" && ERROR_CODE.test(code) && !cardDigits(code) ? `vtex_payments_${code}` : null;
+}
+function vtexPaymentsAnswerOutcome(status, text) {
+    if (!Number.isInteger(status))
+        return { outcome: "unknown", reason: "vtex_payments_unconfirmed" };
+    if (status >= 500)
+        return { outcome: "unknown", reason: "server_error" };
+    if (status >= 400)
+        return { outcome: "refused", code: vtexPaymentsRefusalCode(text) ?? `http_${status}` };
+    if (status === 201 && (text === "" || text === void 0 || text === null))
+        return { outcome: "approved", body: "", pending: "processing" };
+    return { outcome: "unknown", reason: "vtex_payments_unconfirmed" };
+}
+var vtex_payments_default = /* @__PURE__ */ registerProcessor({
+    psp: VTEX_PAYMENTS_PSP,
+    definitions: [
+        {
+            psp: "vtex_payments",
+            // Ollie's card post to a VTEX account's own vault, as the header above reads it, and the fallback host, which
+            // the gate recognizes only to refuse, so the agent's placeholder never reaches it either. VTEX has no test host:
+            // every request is live. Prepared only: Ollie gives the post 12 seconds. Ships dark: served only to a client that
+            // declares `vtex_payments_card_payment`, on for Agentcard's own company alone (backend
+            // checkout-processor-gate.ts), and autopilot never sends it.
+            capability: "vtex_payments_card_payment",
+            match: "[a-z0-9-]{1,63}\\.vtexvault\\.com/api/payments/transactions/[A-Za-z0-9-]{1,64}/payments(?![\\w/.%-])",
+            hosts: ["^[a-z0-9-]{1,63}\\.vtexvault\\.com$"],
+            preparationRequired: true,
+            encoding: "json",
+            // Ollie's fetch sets the JSON content type alone. Origin, Referer and cookies never ride.
+            passthroughHeaders: [],
+            jsonCardFields: [[0, "fields", "cardNumber"]]
+        }
+    ],
+    // Only the cardholder's device sends it, after a person approves; no reviewed list names vtex_payments.
+    refusedOperations: [VTEX_PAYMENTS_OPERATION],
+    // Not surveyed: VTEX names a payment's end only to the store's own API keys and at the gatewayCallback that follows.
+    settlementReadback: "not_surveyed",
+    exactUrl: isVtexPaymentsCardUrl,
+    bodyGate: (url, body) => {
+        if (url === void 0)
+            return vtexPaymentsBodyVerdict(body);
+        const target = vtexPaymentsCardTarget(url);
+        if (target === null)
+            return refuse("vtex_payments_url_refused");
+        return target.fallback ? refuse("vtex_payments_fallback_refused") : vtexPaymentsBodyVerdict(body, target);
+    },
+    amount: (template) => record(template) && isVtexPaymentsCardUrl(template.url) ? vtexPaymentsAmount(template.body) : null
+});
+var device = /* @__PURE__ */ registerDeviceRules(VTEX_PAYMENTS_PSP, {
+    deviceCheck: (request) => {
+        const refusal = vtexPaymentsDeviceRefusal(request);
+        return refusal ? vtexPaymentsRefusalMessage(refusal) : null;
+    },
+    fill: injectVtexPaymentsCard,
+    refusalCode: (text) => vtexPaymentsRefusalCode(text),
+    outcome: (status, text) => vtexPaymentsAnswerOutcome(status, text)
+});
+export { VTEX_PAYMENTS_ADDRESS_KEYS, VTEX_PAYMENTS_CAPABILITY, VTEX_PAYMENTS_FALLBACK_HOST, VTEX_PAYMENTS_FIELD_KEYS, VTEX_PAYMENTS_LINE_KEYS, VTEX_PAYMENTS_MERCHANT_PINS, VTEX_PAYMENTS_NETWORKS, VTEX_PAYMENTS_OPERATION, VTEX_PAYMENTS_PREPARATION_URL, VTEX_PAYMENTS_PSP, VTEX_PAYMENTS_REFUSAL_CODES, vtex_payments_default as default, device, injectVtexPaymentsCard, isPreparedVtexPaymentsRequest, isVtexPaymentsCardUrl, vtexPaymentsAccountPin, vtexPaymentsAmount, vtexPaymentsAnswerOutcome, vtexPaymentsBodyVerdict, vtexPaymentsCardTarget, vtexPaymentsDeviceRefusal, vtexPaymentsMerchantRefusal, vtexPaymentsOriginPin, vtexPaymentsRefusalCode, vtexPaymentsRefusalMessage, vtexPaymentsRequestRefusal };