@vtex/faststore 0.0.4 → 0.0.6

package/dist/sdk/payment/operations.js

@@ -0,0 +1,223 @@
+import { gql } from "../graphql-tag.js";
+import { CartFragment } from "../cart/operations.js";
+//#region src/sdk/payment/operations.ts
+/**
+* The one client-synthesized error code, carried by the userError every mutation-backed method
+* *resolves* (never throws) when its mutation fails at the transport or top-level-GraphQL layer.
+* `gateway.ts` owns the separate code for a failed gateway leg (Decision 7).
+*/
+const PAYMENT_NETWORK_ERROR_CODE = "NETWORK_ERROR";
+/**
+* The canonical `Payment` selection set, spread by every selection mutation so one response
+* re-normalizes the whole entity and every reactive subscriber re-renders with no refetch — the
+* payload-completeness invariant writes must honor (ADR-0010). Selecting the entire entity mirrors
+* `CartFragment` and `SHIPPING_ADDRESS_UPDATE`'s full-`Shipping` selection: the method list (T5), the
+* validator config (T7), `installmentOptions` (T9), and the summary's selection fields (T6) are all
+* subscribed independently, and a partial selection would leave one of them incomplete.
+*/
+const PaymentFragment = gql`
+  fragment PaymentFragment on Payment {
+    __typename
+    id
+    selectedMethodId
+    selectedAccountId
+    selectedBin
+    selectedInstallment {
+      __typename
+      count
+      value {
+        amount
+        currencyCode
+      }
+      total {
+        amount
+        currencyCode
+      }
+      interestRate
+    }
+    installmentOptions {
+      __typename
+      methodId
+      bin
+      baseValue {
+        amount
+        currencyCode
+      }
+      installments {
+        __typename
+        count
+        value {
+          amount
+          currencyCode
+        }
+        total {
+          amount
+          currencyCode
+        }
+        interestRate
+      }
+    }
+    methods {
+      __typename
+      id
+      name
+      groupName
+      validator {
+        __typename
+        numberMask
+        numberRegex
+        cvvMask
+        cvvRegex
+        cvvRequired
+        expirationRequired
+        holderNameRequired
+        billingAddressRequired
+        documentDisplayable
+        documentRequired
+      }
+    }
+    savedCards {
+      __typename
+      id
+      accountId
+      methodId
+      network
+      lastFourDigits
+      bin
+      label
+      expired
+      cvvRequired
+    }
+  }
+`;
+/** The billing-address echo, spread by the three selection mutations that return one. */
+const PaymentBillingAddressFragment = gql`
+  fragment PaymentBillingAddressFragment on Address {
+    __typename
+    id
+    recipientName
+    postalCode
+    country
+    street
+    number
+    complement
+    neighborhood
+    city
+    state
+  }
+`;
+const PAYMENT_METHOD_SELECT = gql`
+  mutation PaymentMethodSelect($input: PaymentMethodSelectInput!) {
+    paymentMethodSelect(input: $input) {
+      __typename
+      payment {
+        ...PaymentFragment
+      }
+      billingAddress {
+        ...PaymentBillingAddressFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+  ${PaymentFragment}
+  ${PaymentBillingAddressFragment}
+`;
+/**
+* Selects `cart { ...CartFragment }` alongside `payment` so the interest-inclusive order total lands
+* in the normalized cache in the same round trip (REQ-03) — the same reason `shippingOptionSelect`
+* selects the cart.
+*/
+const PAYMENT_INSTALLMENT_SELECT = gql`
+  mutation PaymentInstallmentSelect($input: PaymentInstallmentSelectInput!) {
+    paymentInstallmentSelect(input: $input) {
+      __typename
+      payment {
+        ...PaymentFragment
+      }
+      cart {
+        ...CartFragment
+      }
+      billingAddress {
+        ...PaymentBillingAddressFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+  ${PaymentFragment}
+  ${PaymentBillingAddressFragment}
+  ${CartFragment}
+`;
+const PAYMENT_BILLING_ADDRESS_UPDATE = gql`
+  mutation PaymentBillingAddressUpdate($input: PaymentBillingAddressUpdateInput!) {
+    paymentBillingAddressUpdate(input: $input) {
+      __typename
+      billingAddress {
+        ...PaymentBillingAddressFragment
+      }
+      payment {
+        ...PaymentFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+  ${PaymentFragment}
+  ${PaymentBillingAddressFragment}
+`;
+/**
+* Takes no input: every field VTEX's transaction endpoint needs is derived server-side from the
+* already-persisted selection (T3 Decision 9). The transaction cookies it mints ride on the HTTP
+* response, not on the payload.
+*
+* `merchantName`, `gatewayUrl`, `valueInCents`, and `referenceValueInCents` are T18's additions
+* (specs/payment-transaction-payload-gaps.md), selected here by T13: `PaymentGatewayTransaction`
+* requires all four, so the descriptor cannot be assembled without them. `value` stays selected
+* beside the minor-unit pair — it is the display decimal, and the `purchase` analytics event reports
+* it rather than a client-side division.
+*/
+const PAYMENT_START_TRANSACTION = gql`
+  mutation PaymentStartTransaction {
+    paymentStartTransaction {
+      __typename
+      transactionId
+      merchantName
+      gatewayUrl
+      orderGroup
+      userProfileId
+      value {
+        amount
+        currencyCode
+      }
+      valueInCents
+      referenceValueInCents
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`;
+const PAYMENT_GATEWAY_CALLBACK = gql`
+  mutation PaymentGatewayCallback($input: PaymentGatewayCallbackInput!) {
+    paymentGatewayCallback(input: $input) {
+      __typename
+      orderId
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`;
+//#endregion
+export { PAYMENT_BILLING_ADDRESS_UPDATE, PAYMENT_GATEWAY_CALLBACK, PAYMENT_INSTALLMENT_SELECT, PAYMENT_METHOD_SELECT, PAYMENT_NETWORK_ERROR_CODE, PAYMENT_START_TRANSACTION, PaymentBillingAddressFragment, PaymentFragment };
+
+//# sourceMappingURL=operations.js.map

package/dist/sdk/payment/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","names":[],"sources":["../../../src/sdk/payment/operations.ts"],"sourcesContent":["import type { TypedDocumentNode } from '@apollo/client';\nimport { type CartEntity, CartFragment } from '../cart/operations.js';\nimport { gql } from '../graphql-tag.js';\n\n/**\n * Payment write-model GraphQL operations (specs/payment-action-namespace.md, T4) — the five mutations\n * `api-module:PaymentWriteModel` shipped (T3, `checkout/schema.graphql` § 11). Nothing here is\n * invented: every mutation, input field, and payload field is pinned to that schema.\n *\n * Authored with the hand `gql` tag — the codegen `graphql()` factory is reserved for the reactive read\n * path — and excluded from the codegen `documents` glob (see `codegen.ts`): the `gql` tag alone is\n * still plucked by `graphql-codegen`, which would duplicate these hand-written types in\n * `sdk/generated/`. Mirrors `shipping/option-select-operations.ts` and `identity/operations.ts`.\n *\n * No field at any nesting depth carries a card number or CVV — the read model guarantees it (RFC D13),\n * and the one call that does carry them never touches GraphQL at all (see `gateway.ts`).\n *\n * Failures follow ADR-00007's two-path contract: domain outcomes arrive as payload `userErrors`;\n * transport and top-level GraphQL failures are infrastructure, collapsed by the handlers in\n * `use-payment-actions.ts` to the one client-synthesized code, `PAYMENT_NETWORK_ERROR_CODE`.\n */\n\n// ---------------------------------------------------------------------------\n// Domain types — mirror the shipped checkout schema\n// ---------------------------------------------------------------------------\n\n/** A payment domain error. Every mutation's error type is `{ code, message }`; codes stay strings. */\nexport type PaymentUserError = Readonly<{ code: string; message: string }>;\n\n/**\n * The one client-synthesized error code, carried by the userError every mutation-backed method\n * *resolves* (never throws) when its mutation fails at the transport or top-level-GraphQL layer.\n * `gateway.ts` owns the separate code for a failed gateway leg (Decision 7).\n */\nexport const PAYMENT_NETWORK_ERROR_CODE = 'NETWORK_ERROR';\n\nexport type PaymentMoney = Readonly<{ __typename?: 'Money'; amount: number; currencyCode: string }>;\n\ntype PaymentInstallmentEntity = Readonly<{\n  __typename?: 'PaymentInstallment';\n  count: number;\n  value: PaymentMoney;\n  total: PaymentMoney;\n  interestRate: number;\n}>;\n\ntype PaymentMethodValidatorEntity = Readonly<{\n  __typename?: 'PaymentMethodValidator';\n  numberMask: string | null;\n  numberRegex: string | null;\n  cvvMask: string | null;\n  cvvRegex: string | null;\n  cvvRequired: boolean;\n  expirationRequired: boolean;\n  holderNameRequired: boolean;\n  billingAddressRequired: boolean;\n  documentDisplayable: boolean;\n  documentRequired: boolean;\n}>;\n\ntype PaymentMethodEntity = Readonly<{\n  __typename?: 'PaymentMethod';\n  id: string;\n  name: string;\n  groupName: string;\n  validator: PaymentMethodValidatorEntity;\n}>;\n\ntype PaymentInstallmentOptionEntity = Readonly<{\n  __typename?: 'PaymentInstallmentOption';\n  methodId: string;\n  bin: string | null;\n  baseValue: PaymentMoney;\n  installments: readonly PaymentInstallmentEntity[];\n}>;\n\ntype SavedCardEntity = Readonly<{\n  __typename?: 'SavedCard';\n  id: string;\n  accountId: string;\n  methodId: string;\n  network: string;\n  lastFourDigits: string;\n  bin: string;\n  label: string | null;\n  expired: boolean;\n  cvvRequired: boolean;\n}>;\n\n/** The full `Payment` entity every selection mutation echoes back. Never carries a PAN or CVV. */\nexport type PaymentEntity = Readonly<{\n  __typename?: 'Payment';\n  id: string;\n  methods: readonly PaymentMethodEntity[];\n  selectedMethodId: string | null;\n  selectedAccountId: string | null;\n  selectedBin: string | null;\n  selectedInstallment: PaymentInstallmentEntity | null;\n  installmentOptions: readonly PaymentInstallmentOptionEntity[];\n  savedCards: readonly SavedCardEntity[];\n}>;\n\n/** The billing-address echo on the selection payloads — the schema's shared `Address` type. */\nexport type PaymentBillingAddressEntity = Readonly<{\n  __typename?: 'Address';\n  id: string | null;\n  recipientName: string | null;\n  postalCode: string | null;\n  country: string;\n  street: string | null;\n  number: string | null;\n  complement: string | null;\n  neighborhood: string | null;\n  city: string | null;\n  state: string | null;\n}>;\n\n// ---------------------------------------------------------------------------\n// Mutation inputs — mirror the schema's input types verbatim\n// ---------------------------------------------------------------------------\n\n/** A `bin` with an `accountId` is validated against the saved card's own BIN (MISMATCHED_BIN_FOR_SAVED_CARD). */\nexport type PaymentMethodSelectInput = Readonly<{ methodId: string; bin?: string; accountId?: string }>;\n\nexport type PaymentInstallmentSelectInput = Readonly<{ count: number }>;\n\n/** With `sameAsDelivery: true` every other field is ignored and the server performs no upstream write. */\nexport type PaymentBillingAddressUpdateInput = Readonly<{\n  sameAsDelivery: boolean;\n  addressType?: string;\n  postalCode?: string;\n  country?: string;\n  street?: string;\n  number?: string;\n  complement?: string;\n  neighborhood?: string;\n  city?: string;\n  state?: string;\n  reference?: string;\n}>;\n\nexport type PaymentGatewayCallbackInput = Readonly<{ orderGroup: string }>;\n\n// ---------------------------------------------------------------------------\n// Shared fragment\n// ---------------------------------------------------------------------------\n\n/**\n * The canonical `Payment` selection set, spread by every selection mutation so one response\n * re-normalizes the whole entity and every reactive subscriber re-renders with no refetch — the\n * payload-completeness invariant writes must honor (ADR-0010). Selecting the entire entity mirrors\n * `CartFragment` and `SHIPPING_ADDRESS_UPDATE`'s full-`Shipping` selection: the method list (T5), the\n * validator config (T7), `installmentOptions` (T9), and the summary's selection fields (T6) are all\n * subscribed independently, and a partial selection would leave one of them incomplete.\n */\nexport const PaymentFragment = gql`\n  fragment PaymentFragment on Payment {\n    __typename\n    id\n    selectedMethodId\n    selectedAccountId\n    selectedBin\n    selectedInstallment {\n      __typename\n      count\n      value {\n        amount\n        currencyCode\n      }\n      total {\n        amount\n        currencyCode\n      }\n      interestRate\n    }\n    installmentOptions {\n      __typename\n      methodId\n      bin\n      baseValue {\n        amount\n        currencyCode\n      }\n      installments {\n        __typename\n        count\n        value {\n          amount\n          currencyCode\n        }\n        total {\n          amount\n          currencyCode\n        }\n        interestRate\n      }\n    }\n    methods {\n      __typename\n      id\n      name\n      groupName\n      validator {\n        __typename\n        numberMask\n        numberRegex\n        cvvMask\n        cvvRegex\n        cvvRequired\n        expirationRequired\n        holderNameRequired\n        billingAddressRequired\n        documentDisplayable\n        documentRequired\n      }\n    }\n    savedCards {\n      __typename\n      id\n      accountId\n      methodId\n      network\n      lastFourDigits\n      bin\n      label\n      expired\n      cvvRequired\n    }\n  }\n`;\n\n/** The billing-address echo, spread by the three selection mutations that return one. */\nexport const PaymentBillingAddressFragment = gql`\n  fragment PaymentBillingAddressFragment on Address {\n    __typename\n    id\n    recipientName\n    postalCode\n    country\n    street\n    number\n    complement\n    neighborhood\n    city\n    state\n  }\n`;\n\n// ---------------------------------------------------------------------------\n// Mutation operations\n// ---------------------------------------------------------------------------\n\ntype PaymentMethodSelectMutation = Readonly<{\n  paymentMethodSelect: Readonly<{\n    __typename?: 'PaymentMethodSelectPayload';\n    payment: PaymentEntity | null;\n    billingAddress: PaymentBillingAddressEntity | null;\n    userErrors: readonly PaymentUserError[];\n  }>;\n}>;\n\nexport const PAYMENT_METHOD_SELECT: TypedDocumentNode<\n  PaymentMethodSelectMutation,\n  Readonly<{ input: PaymentMethodSelectInput }>\n> = gql`\n  mutation PaymentMethodSelect($input: PaymentMethodSelectInput!) {\n    paymentMethodSelect(input: $input) {\n      __typename\n      payment {\n        ...PaymentFragment\n      }\n      billingAddress {\n        ...PaymentBillingAddressFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n  ${PaymentFragment}\n  ${PaymentBillingAddressFragment}\n`;\n\ntype PaymentInstallmentSelectMutation = Readonly<{\n  paymentInstallmentSelect: Readonly<{\n    __typename?: 'PaymentInstallmentSelectPayload';\n    payment: PaymentEntity | null;\n    cart: CartEntity | null;\n    billingAddress: PaymentBillingAddressEntity | null;\n    userErrors: readonly PaymentUserError[];\n  }>;\n}>;\n\n/**\n * Selects `cart { ...CartFragment }` alongside `payment` so the interest-inclusive order total lands\n * in the normalized cache in the same round trip (REQ-03) — the same reason `shippingOptionSelect`\n * selects the cart.\n */\nexport const PAYMENT_INSTALLMENT_SELECT: TypedDocumentNode<\n  PaymentInstallmentSelectMutation,\n  Readonly<{ input: PaymentInstallmentSelectInput }>\n> = gql`\n  mutation PaymentInstallmentSelect($input: PaymentInstallmentSelectInput!) {\n    paymentInstallmentSelect(input: $input) {\n      __typename\n      payment {\n        ...PaymentFragment\n      }\n      cart {\n        ...CartFragment\n      }\n      billingAddress {\n        ...PaymentBillingAddressFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n  ${PaymentFragment}\n  ${PaymentBillingAddressFragment}\n  ${CartFragment}\n`;\n\ntype PaymentBillingAddressUpdateMutation = Readonly<{\n  paymentBillingAddressUpdate: Readonly<{\n    __typename?: 'PaymentBillingAddressUpdatePayload';\n    billingAddress: PaymentBillingAddressEntity | null;\n    payment: PaymentEntity | null;\n    userErrors: readonly PaymentUserError[];\n  }>;\n}>;\n\nexport const PAYMENT_BILLING_ADDRESS_UPDATE: TypedDocumentNode<\n  PaymentBillingAddressUpdateMutation,\n  Readonly<{ input: PaymentBillingAddressUpdateInput }>\n> = gql`\n  mutation PaymentBillingAddressUpdate($input: PaymentBillingAddressUpdateInput!) {\n    paymentBillingAddressUpdate(input: $input) {\n      __typename\n      billingAddress {\n        ...PaymentBillingAddressFragment\n      }\n      payment {\n        ...PaymentFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n  ${PaymentFragment}\n  ${PaymentBillingAddressFragment}\n`;\n\ntype PaymentStartTransactionMutation = Readonly<{\n  paymentStartTransaction: Readonly<{\n    __typename?: 'PaymentStartTransactionPayload';\n    transactionId: string | null;\n    merchantName: string | null;\n    gatewayUrl: string | null;\n    orderGroup: string | null;\n    userProfileId: string | null;\n    value: PaymentMoney | null;\n    valueInCents: number | null;\n    referenceValueInCents: number | null;\n    userErrors: readonly PaymentUserError[];\n  }>;\n}>;\n\n/**\n * Takes no input: every field VTEX's transaction endpoint needs is derived server-side from the\n * already-persisted selection (T3 Decision 9). The transaction cookies it mints ride on the HTTP\n * response, not on the payload.\n *\n * `merchantName`, `gatewayUrl`, `valueInCents`, and `referenceValueInCents` are T18's additions\n * (specs/payment-transaction-payload-gaps.md), selected here by T13: `PaymentGatewayTransaction`\n * requires all four, so the descriptor cannot be assembled without them. `value` stays selected\n * beside the minor-unit pair — it is the display decimal, and the `purchase` analytics event reports\n * it rather than a client-side division.\n */\nexport const PAYMENT_START_TRANSACTION: TypedDocumentNode<PaymentStartTransactionMutation, Record<string, never>> = gql`\n  mutation PaymentStartTransaction {\n    paymentStartTransaction {\n      __typename\n      transactionId\n      merchantName\n      gatewayUrl\n      orderGroup\n      userProfileId\n      value {\n        amount\n        currencyCode\n      }\n      valueInCents\n      referenceValueInCents\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`;\n\ntype PaymentGatewayCallbackMutation = Readonly<{\n  paymentGatewayCallback: Readonly<{\n    __typename?: 'PaymentGatewayCallbackPayload';\n    orderId: string | null;\n    userErrors: readonly PaymentUserError[];\n  }>;\n}>;\n\nexport const PAYMENT_GATEWAY_CALLBACK: TypedDocumentNode<\n  PaymentGatewayCallbackMutation,\n  Readonly<{ input: PaymentGatewayCallbackInput }>\n> = gql`\n  mutation PaymentGatewayCallback($input: PaymentGatewayCallbackInput!) {\n    paymentGatewayCallback(input: $input) {\n      __typename\n      orderId\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`;\n"],"mappings":";;;;;;;;AAkCA,MAAa,6BAA6B;;;;;;;;;AAyH1C,MAAa,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6ElC,MAAa,gCAAgC,GAAG;;;;;;;;;;;;;;;AA6BhD,MAAa,wBAGT,GAAG;;;;;;;;;;;;;;;;IAgBH,gBAAgB;IAChB,8BAA8B;;;;;;;AAkBlC,MAAa,6BAGT,GAAG;;;;;;;;;;;;;;;;;;;IAmBH,gBAAgB;IAChB,8BAA8B;IAC9B,aAAa;;AAYjB,MAAa,iCAGT,GAAG;;;;;;;;;;;;;;;;IAgBH,gBAAgB;IAChB,8BAA8B;;;;;;;;;;;;;AA6BlC,MAAa,4BAAuG,GAAG;;;;;;;;;;;;;;;;;;;;;;AA+BvH,MAAa,2BAGT,GAAG"}

package/dist/sdk/payment/security-code-mask.js

@@ -0,0 +1,71 @@
+//#region src/sdk/payment/security-code-mask.ts
+/**
+* The security-code masking mechanism (specs/choose-a-security-code-masking-mechanism.md, T101 of
+* the Credit Card epic; docs/features/credit-card/rfc.md § D13). One shared constant for the two
+* inputs that hold a security code — `CardEntry`'s `cvv` field and `SavedCardCvvField`'s CVV
+* re-entry field — so the two call sites cannot drift on the mechanism.
+*
+* Why this and not `type="password"`: T70 shipped `type="password"` on both fields and it made real
+* Chrome offer a "Save password?" prompt on the new-card form — pairing the expiration date as a
+* fake *Username* and the security code as *Password*, and offering to store it in Google Password
+* Manager, synced to the signed-in account. PCI-DSS forbids retaining the security code past
+* authorization, and a cloud-synced credential vault is a strictly worse posture than the field's
+* pre-T70 baseline. `type="password"` was reverted; both fields ship `type="text"`.
+*
+* `-webkit-text-security: disc` obscures the digits on screen without touching `type`, so the
+* heuristic that triggered the prompt (keyed off `type="password"` fields in the form) never fires —
+* settled by the 2026-08-24 unblock ruling through measurement in real Chrome, not documentation.
+* Applied as an **element inline style**, never a stylesheet the package ships (forbidden by
+* ADR-0007's Consequences, `:104`) and never a class a store authors (defeatable by any compound
+* swatch) — an inline declaration is the one CSS route that is both within the architecture rule and
+* outside the store's reach, and it outranks every class-based rule at normal importance.
+*
+* This closes the password-manager capture surface structurally — it does not mean the code never
+* leaves the browser by any path. `CardEntry`'s CVV keeps `autoComplete="cc-csc"` (FR-5, unchanged by
+* this task): the exact token Chrome's own Autofill uses to classify the field as
+* `CREDIT_CARD_VERIFICATION_CODE`, and Chrome ships CVC storage (`AutofillEnableCvcStorageAndFilling`)
+* that retains the CVC beside a saved server card and syncs it to the signed-in Google account. This
+* mechanism does not close that path and is not trying to — it is the separate *card* vault the field
+* honestly declares itself to via `autoComplete`, not the credential vault this change removes (spec
+* § Verification, G1(d)).
+*
+* `WebkitTextSecurity` is asserted `as CSSProperties` because csstype 3.2.3 declares no such key —
+* mirrors the existing assertion in `variant-selector.tsx`. The property is standardized nowhere;
+* supported in Chromium and WebKit (and Firefox 114+, per T70's spec). An engine without it renders
+* exactly what ships today — not a regression.
+*
+* Defined once at module scope so the object is referentially stable and React's style diffing never
+* has work to do on re-render.
+*/
+const SECURITY_CODE_MASK_STYLE = Object.freeze({ WebkitTextSecurity: "disc" });
+/**
+* Whether the security code is fully typed — the moment `SECURITY_CODE_MASK_STYLE` above starts
+* applying (specs/mask-the-cvv-only-once-it.md, T173). Until then the field renders its digits in
+* the clear, so a shopper can read back what they just typed and catch a typo; from then on it
+* renders exactly as it did when the mask was unconditional. The mechanism is untouched; only its
+* timing moves. Never on blur, never after a delay: the mask engages on the keystroke that completes
+* the code.
+*
+* `expectedLength` is passed in because the two fields resolve it from different places and neither
+* belongs in this module: `CardEntry` takes the detected network's `cvvMask` (three digits for most
+* networks, four for Amex), while `SavedCardCvvField` has no per-network length at all and uses its
+* own three-or-four-digit floor. Resolving it here would mean knowing about payment-method validators
+* and saved-card rows, and would still leave the comparison itself free to drift between the two.
+*
+* Both callers resolve a *floor*, and a ceiling would be a defect rather than a variation: whatever
+* length arrives here is the length at which digits stop being legible, so the widest of several
+* possible lengths leaves a code that is already complete for a shorter one readable for the rest of
+* the flow.
+*
+* Derived from the value on every render, with no state and no timer. That is what makes the render
+* which first holds a complete code already the masked one — so a paste delivering every digit in one
+* event opens no legible frame — lets a cleared field unmask with nothing to reset, and leaves a code
+* the shopper backspaces into legible again while they correct it.
+*/
+function isSecurityCodeComplete(value, expectedLength) {
+	return value.length > 0 && value.length >= expectedLength;
+}
+//#endregion
+export { SECURITY_CODE_MASK_STYLE, isSecurityCodeComplete };
+
+//# sourceMappingURL=security-code-mask.js.map

package/dist/sdk/payment/security-code-mask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-code-mask.js","names":[],"sources":["../../../src/sdk/payment/security-code-mask.ts"],"sourcesContent":["import type { CSSProperties } from 'react';\n\n/**\n * The security-code masking mechanism (specs/choose-a-security-code-masking-mechanism.md, T101 of\n * the Credit Card epic; docs/features/credit-card/rfc.md § D13). One shared constant for the two\n * inputs that hold a security code — `CardEntry`'s `cvv` field and `SavedCardCvvField`'s CVV\n * re-entry field — so the two call sites cannot drift on the mechanism.\n *\n * Why this and not `type=\"password\"`: T70 shipped `type=\"password\"` on both fields and it made real\n * Chrome offer a \"Save password?\" prompt on the new-card form — pairing the expiration date as a\n * fake *Username* and the security code as *Password*, and offering to store it in Google Password\n * Manager, synced to the signed-in account. PCI-DSS forbids retaining the security code past\n * authorization, and a cloud-synced credential vault is a strictly worse posture than the field's\n * pre-T70 baseline. `type=\"password\"` was reverted; both fields ship `type=\"text\"`.\n *\n * `-webkit-text-security: disc` obscures the digits on screen without touching `type`, so the\n * heuristic that triggered the prompt (keyed off `type=\"password\"` fields in the form) never fires —\n * settled by the 2026-08-24 unblock ruling through measurement in real Chrome, not documentation.\n * Applied as an **element inline style**, never a stylesheet the package ships (forbidden by\n * ADR-0007's Consequences, `:104`) and never a class a store authors (defeatable by any compound\n * swatch) — an inline declaration is the one CSS route that is both within the architecture rule and\n * outside the store's reach, and it outranks every class-based rule at normal importance.\n *\n * This closes the password-manager capture surface structurally — it does not mean the code never\n * leaves the browser by any path. `CardEntry`'s CVV keeps `autoComplete=\"cc-csc\"` (FR-5, unchanged by\n * this task): the exact token Chrome's own Autofill uses to classify the field as\n * `CREDIT_CARD_VERIFICATION_CODE`, and Chrome ships CVC storage (`AutofillEnableCvcStorageAndFilling`)\n * that retains the CVC beside a saved server card and syncs it to the signed-in Google account. This\n * mechanism does not close that path and is not trying to — it is the separate *card* vault the field\n * honestly declares itself to via `autoComplete`, not the credential vault this change removes (spec\n * § Verification, G1(d)).\n *\n * `WebkitTextSecurity` is asserted `as CSSProperties` because csstype 3.2.3 declares no such key —\n * mirrors the existing assertion in `variant-selector.tsx`. The property is standardized nowhere;\n * supported in Chromium and WebKit (and Firefox 114+, per T70's spec). An engine without it renders\n * exactly what ships today — not a regression.\n *\n * Defined once at module scope so the object is referentially stable and React's style diffing never\n * has work to do on re-render.\n */\nexport const SECURITY_CODE_MASK_STYLE: CSSProperties = Object.freeze({ WebkitTextSecurity: 'disc' }) as CSSProperties;\n\n/**\n * Whether the security code is fully typed — the moment `SECURITY_CODE_MASK_STYLE` above starts\n * applying (specs/mask-the-cvv-only-once-it.md, T173). Until then the field renders its digits in\n * the clear, so a shopper can read back what they just typed and catch a typo; from then on it\n * renders exactly as it did when the mask was unconditional. The mechanism is untouched; only its\n * timing moves. Never on blur, never after a delay: the mask engages on the keystroke that completes\n * the code.\n *\n * `expectedLength` is passed in because the two fields resolve it from different places and neither\n * belongs in this module: `CardEntry` takes the detected network's `cvvMask` (three digits for most\n * networks, four for Amex), while `SavedCardCvvField` has no per-network length at all and uses its\n * own three-or-four-digit floor. Resolving it here would mean knowing about payment-method validators\n * and saved-card rows, and would still leave the comparison itself free to drift between the two.\n *\n * Both callers resolve a *floor*, and a ceiling would be a defect rather than a variation: whatever\n * length arrives here is the length at which digits stop being legible, so the widest of several\n * possible lengths leaves a code that is already complete for a shorter one readable for the rest of\n * the flow.\n *\n * Derived from the value on every render, with no state and no timer. That is what makes the render\n * which first holds a complete code already the masked one — so a paste delivering every digit in one\n * event opens no legible frame — lets a cleared field unmask with nothing to reset, and leaves a code\n * the shopper backspaces into legible again while they correct it.\n */\nexport function isSecurityCodeComplete(value: string, expectedLength: number): boolean {\n  // The length guard is not redundant with `>=`: a store-configured empty `cvvMask` resolves to a\n  // zero expected length, which on its own would read an untouched field as fully typed.\n  return value.length > 0 && value.length >= expectedLength;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,2BAA0C,OAAO,OAAO,EAAE,oBAAoB,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BnG,SAAgB,uBAAuB,OAAe,gBAAiC;CAGrF,OAAO,MAAM,SAAS,KAAK,MAAM,UAAU;AAC7C"}

package/dist/sdk/payment/submission-registry.d.ts

@@ -0,0 +1,33 @@
+import "./operations.js";
+import "./gateway.js";
+import { ReactNode } from "react";
+//#region src/sdk/payment/submission-registry.d.ts
+/**
+ * The card-data submission channel (specs/use-place-order.md, Decision 1; specs/epics/credit-card.md
+ * § "The card-data submission channel"). **The holder submits; the orchestrator never holds.**
+ *
+ * T7 (new card) and T12 (saved card) each register a submit-time continuation here. Each closes over
+ * its own card fields, builds the gateway card object inside that closure, calls
+ * `$actions.payment.sendPayments` itself, and returns only the gateway leg's `userErrors`. T13's
+ * `usePlaceOrder` resolves one by `path` and invokes it between start-transaction and
+ * gateway-callback, so no card-shaped field appears anywhere in this channel's type signature.
+ *
+ * It is a *second*, narrow context beside T5's `payment` context rather than a field on it, because
+ * the two have different shapes and different readers: `draft` is render state every leaf reads, this
+ * is an imperative registry exactly two components write and one hook reads. Registration is a
+ * ref-held `Map`, not state — T7 re-registers a fresh closure on every keystroke, and making that a
+ * render would re-render the whole payment section per character.
+ *
+ * Values that are **not** sensitive travel on T5's `draft`, never here: the save-card flag and label
+ * (T10), the cardholder document (T8), and the billing-address-differs flag (T11). The holder folds
+ * them into the card object inside its own closure.
+ *
+ * This module lives in the SDK rather than beside T5's roots so the layering stays `matter → sdk`:
+ * `usePlaceOrder` is an SDK hook and cannot import from `matter/`. "Provided by T5's root" means the
+ * root renders `PaymentSubmissionProvider`, which it does — both of them, for the same ADR-0009
+ * reason the `payment` context has two providers.
+ */
+/** Which entry path a submission serves. The canonical key type; T5's `PaymentPath` aliases it. */
+export type PaymentSubmissionPath = 'new-card' | 'saved-card';
+//#endregion
+//# sourceMappingURL=submission-registry.d.ts.map

package/dist/sdk/payment/submission-registry.js

@@ -0,0 +1,58 @@
+"use client";
+import { createContext, useContext, useEffect, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/sdk/payment/submission-registry.tsx
+const SUBMISSION_CONTEXT_UNSET = Symbol("PaymentSubmissionContextUnset");
+const PaymentSubmissionContext = createContext(SUBMISSION_CONTEXT_UNSET);
+/** Rendered by `PaymentSectionRoot` and `PaymentSectionController` around the section composition. */
+function PaymentSubmissionProvider({ path, children }) {
+	const submissions = useRef(/* @__PURE__ */ new Map());
+	const channel = useMemo(() => ({
+		path,
+		register: (registeredPath, submit, preflight) => {
+			submissions.current.set(registeredPath, {
+				submit,
+				preflight: preflight ?? null
+			});
+			return () => {
+				if (submissions.current.get(registeredPath)?.submit === submit) submissions.current.delete(registeredPath);
+			};
+		},
+		resolve: (registeredPath) => submissions.current.get(registeredPath)?.submit ?? null,
+		resolvePreflight: (registeredPath) => submissions.current.get(registeredPath)?.preflight ?? null
+	}), [path]);
+	return /* @__PURE__ */ jsx(PaymentSubmissionContext, {
+		value: channel,
+		children
+	});
+}
+/**
+* Read the submission channel from the nearest `PaymentSectionRoot` or `PaymentSectionController`.
+* Throws outside either subtree, mirroring `usePayment()`: a misplaced holder or CTA is a composition
+* bug the author should see immediately. Distinct from the two *runtime* states — no path chosen, no
+* continuation registered — which `usePlaceOrder` resolves as a userError.
+*/
+function usePaymentSubmission() {
+	const channel = useContext(PaymentSubmissionContext);
+	if (channel === SUBMISSION_CONTEXT_UNSET) throw new Error("usePaymentSubmission() must be used inside a <PaymentSectionRoot> or <PaymentSectionController> subtree.");
+	return channel;
+}
+/**
+* The holder-facing signature (T7, T12; `preflight` added by T27). Registers `submit` — and,
+* optionally, its pre-flight check — for `path`, and unregisters on unmount or on any argument
+* changing, so the map always holds the latest closures over the holder's card fields — a stale one
+* would pay with the previous keystroke's CVV.
+*/
+function useRegisterPaymentSubmission(path, submit, preflight) {
+	const { register } = usePaymentSubmission();
+	useEffect(() => register(path, submit, preflight), [
+		register,
+		path,
+		submit,
+		preflight
+	]);
+}
+//#endregion
+export { PaymentSubmissionProvider, usePaymentSubmission, useRegisterPaymentSubmission };
+
+//# sourceMappingURL=submission-registry.js.map

package/dist/sdk/payment/submission-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"submission-registry.js","names":[],"sources":["../../../src/sdk/payment/submission-registry.tsx"],"sourcesContent":["'use client';\n\nimport { createContext, type ReactNode, useContext, useEffect, useMemo, useRef } from 'react';\nimport type { PaymentGatewayTransaction } from './gateway.js';\nimport type { PaymentUserError } from './operations.js';\n\n/**\n * The card-data submission channel (specs/use-place-order.md, Decision 1; specs/epics/credit-card.md\n * § \"The card-data submission channel\"). **The holder submits; the orchestrator never holds.**\n *\n * T7 (new card) and T12 (saved card) each register a submit-time continuation here. Each closes over\n * its own card fields, builds the gateway card object inside that closure, calls\n * `$actions.payment.sendPayments` itself, and returns only the gateway leg's `userErrors`. T13's\n * `usePlaceOrder` resolves one by `path` and invokes it between start-transaction and\n * gateway-callback, so no card-shaped field appears anywhere in this channel's type signature.\n *\n * It is a *second*, narrow context beside T5's `payment` context rather than a field on it, because\n * the two have different shapes and different readers: `draft` is render state every leaf reads, this\n * is an imperative registry exactly two components write and one hook reads. Registration is a\n * ref-held `Map`, not state — T7 re-registers a fresh closure on every keystroke, and making that a\n * render would re-render the whole payment section per character.\n *\n * Values that are **not** sensitive travel on T5's `draft`, never here: the save-card flag and label\n * (T10), the cardholder document (T8), and the billing-address-differs flag (T11). The holder folds\n * them into the card object inside its own closure.\n *\n * This module lives in the SDK rather than beside T5's roots so the layering stays `matter → sdk`:\n * `usePlaceOrder` is an SDK hook and cannot import from `matter/`. \"Provided by T5's root\" means the\n * root renders `PaymentSubmissionProvider`, which it does — both of them, for the same ADR-0009\n * reason the `payment` context has two providers.\n */\n\n/** Which entry path a submission serves. The canonical key type; T5's `PaymentPath` aliases it. */\nexport type PaymentSubmissionPath = 'new-card' | 'saved-card';\n\n/**\n * A holder's submit-time continuation — the whole channel. It takes the non-sensitive transaction\n * descriptor and resolves the gateway leg's `userErrors` (empty on success). It must not log,\n * serialize, or return the card.\n */\nexport type PaymentSubmission = (transaction: PaymentGatewayTransaction) => Promise<readonly PaymentUserError[]>;\n\n/**\n * A holder's pre-flight verdict on its own draft, resolved before any transaction opens (T27,\n * specs/place-order-preflight-card-validation.md). Returns the refusals that would make this\n * submission pointless, or an empty array to proceed. Synchronous by contract (Decision 6): a holder\n * validates what it already holds and performs no I/O.\n *\n * Card-free by the same rule the submission itself follows — it returns `PaymentUserError`s and never\n * the fields it inspected. It may have side effects inside its own component (rendering field errors,\n * moving focus); that is the half a value-shaped gate cannot carry.\n */\nexport type PaymentPreflightCheck = () => readonly PaymentUserError[];\n\n/** One path's registration. `preflight` is `null` when its holder registered none (FR-6). */\ntype PaymentSubmissionEntry = Readonly<{\n  submit: PaymentSubmission;\n  preflight: PaymentPreflightCheck | null;\n}>;\n\nexport type PaymentSubmissionChannel = Readonly<{\n  /**\n   * The entry path the shopper is on — T5's `draft.path`, mirrored here so the place-order sequence\n   * resolves it without reading the matter context. One-way and derived: the root passes it through\n   * on every render.\n   */\n  path: PaymentSubmissionPath | null;\n  /** Registers (or replaces) the continuation, and optionally its pre-flight check, for a path. Returns its unregister function. */\n  register: (path: PaymentSubmissionPath, submit: PaymentSubmission, preflight?: PaymentPreflightCheck) => () => void;\n  /** Unchanged: the continuation registered for a path, or `null` when its holder is not composed or unmounted. */\n  resolve: (path: PaymentSubmissionPath) => PaymentSubmission | null;\n  /** The pre-flight check registered for a path, or `null` when its holder registered none. */\n  resolvePreflight: (path: PaymentSubmissionPath) => PaymentPreflightCheck | null;\n}>;\n\nconst SUBMISSION_CONTEXT_UNSET = Symbol('PaymentSubmissionContextUnset');\n\nconst PaymentSubmissionContext = createContext<PaymentSubmissionChannel | typeof SUBMISSION_CONTEXT_UNSET>(\n  SUBMISSION_CONTEXT_UNSET,\n);\n\nexport type PaymentSubmissionProviderProps = Readonly<{\n  /** T5's `draft.path`. */\n  path: PaymentSubmissionPath | null;\n  children: ReactNode;\n}>;\n\n/** Rendered by `PaymentSectionRoot` and `PaymentSectionController` around the section composition. */\nexport function PaymentSubmissionProvider({ path, children }: PaymentSubmissionProviderProps) {\n  const submissions = useRef(new Map<PaymentSubmissionPath, PaymentSubmissionEntry>());\n\n  const channel = useMemo<PaymentSubmissionChannel>(\n    () => ({\n      path,\n      register: (registeredPath, submit, preflight) => {\n        submissions.current.set(registeredPath, { submit, preflight: preflight ?? null });\n        return () => {\n          // Delete only if this registration is still the one on file: a Map holds one entry per\n          // path, so an unmounting holder whose registration was already superseded by a still-mounted\n          // sibling under the same path must not wipe that sibling's live continuation (or its check).\n          if (submissions.current.get(registeredPath)?.submit === submit) {\n            submissions.current.delete(registeredPath);\n          }\n        };\n      },\n      resolve: (registeredPath) => submissions.current.get(registeredPath)?.submit ?? null,\n      resolvePreflight: (registeredPath) => submissions.current.get(registeredPath)?.preflight ?? null,\n    }),\n    [path],\n  );\n\n  return <PaymentSubmissionContext value={channel}>{children}</PaymentSubmissionContext>;\n}\n\n/**\n * Read the submission channel from the nearest `PaymentSectionRoot` or `PaymentSectionController`.\n * Throws outside either subtree, mirroring `usePayment()`: a misplaced holder or CTA is a composition\n * bug the author should see immediately. Distinct from the two *runtime* states — no path chosen, no\n * continuation registered — which `usePlaceOrder` resolves as a userError.\n */\nexport function usePaymentSubmission(): PaymentSubmissionChannel {\n  const channel = useContext(PaymentSubmissionContext);\n  if (channel === SUBMISSION_CONTEXT_UNSET) {\n    throw new Error(\n      'usePaymentSubmission() must be used inside a <PaymentSectionRoot> or <PaymentSectionController> subtree.',\n    );\n  }\n  return channel;\n}\n\n/**\n * The holder-facing signature (T7, T12; `preflight` added by T27). Registers `submit` — and,\n * optionally, its pre-flight check — for `path`, and unregisters on unmount or on any argument\n * changing, so the map always holds the latest closures over the holder's card fields — a stale one\n * would pay with the previous keystroke's CVV.\n */\nexport function useRegisterPaymentSubmission(\n  path: PaymentSubmissionPath,\n  submit: PaymentSubmission,\n  preflight?: PaymentPreflightCheck,\n): void {\n  const { register } = usePaymentSubmission();\n\n  useEffect(() => register(path, submit, preflight), [register, path, submit, preflight]);\n}\n"],"mappings":";;;;AA2EA,MAAM,2BAA2B,OAAO,+BAA+B;AAEvE,MAAM,2BAA2B,cAC/B,wBACF;;AASA,SAAgB,0BAA0B,EAAE,MAAM,YAA4C;CAC5F,MAAM,cAAc,uBAAO,IAAI,IAAmD,CAAC;CAEnF,MAAM,UAAU,eACP;EACL;EACA,WAAW,gBAAgB,QAAQ,cAAc;GAC/C,YAAY,QAAQ,IAAI,gBAAgB;IAAE;IAAQ,WAAW,aAAa;GAAK,CAAC;GAChF,aAAa;IAIX,IAAI,YAAY,QAAQ,IAAI,cAAc,CAAC,EAAE,WAAW,QACtD,YAAY,QAAQ,OAAO,cAAc;GAE7C;EACF;EACA,UAAU,mBAAmB,YAAY,QAAQ,IAAI,cAAc,CAAC,EAAE,UAAU;EAChF,mBAAmB,mBAAmB,YAAY,QAAQ,IAAI,cAAc,CAAC,EAAE,aAAa;CAC9F,IACA,CAAC,IAAI,CACP;CAEA,OAAO,oBAAC,0BAAD;EAA0B,OAAO;EAAU;CAAmC,CAAA;AACvF;;;;;;;AAQA,SAAgB,uBAAiD;CAC/D,MAAM,UAAU,WAAW,wBAAwB;CACnD,IAAI,YAAY,0BACd,MAAM,IAAI,MACR,0GACF;CAEF,OAAO;AACT;;;;;;;AAQA,SAAgB,6BACd,MACA,QACA,WACM;CACN,MAAM,EAAE,aAAa,qBAAqB;CAE1C,gBAAgB,SAAS,MAAM,QAAQ,SAAS,GAAG;EAAC;EAAU;EAAM;EAAQ;CAAS,CAAC;AACxF"}

package/dist/sdk/payment/use-payment-actions.d.ts

@@ -0,0 +1,78 @@
+import "../../core/dist/index.js";
+import { PaymentBillingAddressUpdateInput, PaymentMethodSelectInput, PaymentMoney, PaymentUserError } from "./operations.js";
+import { SendPaymentsRequest } from "./gateway.js";
+//#region src/sdk/payment/use-payment-actions.d.ts
+/**
+ * The `payment` action namespace — the sanctioned client write surface for credit-card payment
+ * (specs/payment-action-namespace.md; docs/features/credit-card/rfc.md § D12;
+ * docs/storefront-core/adr-0010-actions-own-the-write-side.md).
+ *
+ * Six mutation-backed methods run the write model T3 shipped (`checkout/schema.graphql` § 11), except
+ * `saveCard`, which reuses the already-shipped `clientPreferencesUpdate` document this package owns —
+ * there is no `paymentSaveCard` mutation and T3 decided there must not be one. All six are
+ * async/pessimistic: the handler awaits the mutation and only the server-confirmed payload changes the
+ * cache. Each is stateless (no reactive vars, no module state), resolves its payload `userErrors` (empty
+ * on success), and never throws for an expected outcome; an infrastructure failure (transport or an
+ * upstream GraphQLError) is caught and collapsed to one synthetic `NETWORK_ERROR` userError with no
+ * per-code branching, mirroring `useShippingActions`.
+ *
+ * `sendPayments` is the seventh method and the odd one: a **façade** (ADR-0010's sanctioned flavor,
+ * alongside `notifications`) that posts card data from the browser straight to the payment gateway,
+ * touching neither our GraphQL layer nor the normalized cache. It is catalogued like any other method —
+ * per D12, hiding a write route with no read-back would cost discoverability without protecting
+ * anything, and the compiler wants to *see* which components reference it. What is deliberately absent
+ * from the catalog is the card data itself: no `payload` entry below names a card number, CVV, expiry,
+ * or holder name, so there is no schema-bindable name for the editor or the agent to map a value onto
+ * (RFC D13). The card reaches the handler as a runtime argument from the card-entry component's local
+ * state (T7), and `gateway.ts` — which has no Apollo import — is the only module that touches it.
+ */
+/**
+ * Everything `usePlaceOrder` (T13) needs to assemble `PaymentGatewayTransaction`, minus the five
+ * fields that come from the `Payment` read model. Every field is nullable because a payload carrying
+ * `userErrors` nulls all of them (T18 Decision 4), so a complete descriptor is only guaranteed once
+ * `userErrors` is empty *and* the payload passes the caller's completeness check.
+ */
+export type PaymentStartTransactionResult = Readonly<{
+  transactionId: string | null;
+  merchantName: string | null;
+  /** Gateway origin. Nullable, and never interpolated into a URL before `isTrustedGatewayOrigin`. */
+  gatewayUrl: string | null;
+  orderGroup: string | null;
+  userProfileId: string | null;
+  /** Display decimal. The gateway body's unit is `valueInCents`. */
+  value: PaymentMoney | null;
+  valueInCents: number | null;
+  referenceValueInCents: number | null;
+  userErrors: readonly PaymentUserError[];
+}>;
+export type PaymentGatewayCallbackResult = Readonly<{
+  orderId: string | null;
+  userErrors: readonly PaymentUserError[];
+}>;
+export type PaymentActions = Readonly<{
+  /** Select a payment method, optionally identifying a new card's BIN or a saved card's account. */
+  setMethod: (input: PaymentMethodSelectInput) => Promise<readonly PaymentUserError[]>;
+  /** Select an installment count for the current method. The response carries the recomputed cart total. */
+  setInstallments: (count: number) => Promise<readonly PaymentUserError[]>;
+  /** Persist the billing address, or fall back to the delivery address (`sameAsDelivery: true`). */
+  setBillingAddress: (input: PaymentBillingAddressUpdateInput) => Promise<readonly PaymentUserError[]>;
+  /**
+   * Record the data-storage consent a saved card requires, over the existing `clientPreferencesUpdate`.
+   * This does not by itself save the card: the save flag and label travel on `sendPayments`'s card
+   * argument (RFC D5's two halves). The boolean passes through unchanged — whether unchecking should
+   * revoke a consent an unrelated opt-in component may have granted is T10's decision, and its spec must
+   * state one (Gap 4 in specs/payment-action-namespace.md).
+   */
+  saveCard: (enabled: boolean) => Promise<readonly PaymentUserError[]>;
+  /** Open a VTEX transaction from the persisted selection. Resolves the payload the gateway call needs. */
+  startTransaction: () => Promise<PaymentStartTransactionResult>;
+  /** Finalize the transaction after the gateway accepted the card. */
+  gatewayCallback: (orderGroup: string) => Promise<PaymentGatewayCallbackResult>;
+  /**
+   * Façade: post the card straight to the payment gateway. Issues no GraphQL operation and writes
+   * nothing to the cache. Resolves one `GATEWAY_ERROR` userError when the gateway rejects the call.
+   */
+  sendPayments: (request: SendPaymentsRequest) => Promise<readonly PaymentUserError[]>;
+}>;
+//#endregion
+//# sourceMappingURL=use-payment-actions.d.ts.map