@heyama/pay-react-native 0.0.0-stage → 1.0.0

package/dist/checkout-core/models/checkout.enum.d.ts

@@ -0,0 +1,131 @@
+export declare enum CheckoutScreenEnum {
+    LOADING = "loading",
+    FORM = "form",
+    SUBMITTING = "submitting",
+    WAITING = "waiting",
+    /** The last attempt failed: why, a retry and another method. */
+    FAILED = "failed",
+    SUCCESS = "success",
+    EXPIRED = "expired",
+    CANCELLED = "cancelled",
+    LOCKED = "locked",
+    INVALID = "invalid",
+    /** Every method went off since the link was made: nothing to pay with. */
+    NO_METHOD = "no_method",
+    REDIRECT = "redirect"
+}
+/** Values are the `preferredTab` an app may send. */
+export declare enum CheckoutTabEnum {
+    MOBILE_MONEY = "mobile_money",
+    CARD = "card"
+}
+/** GLOSSARY: Payment. Values are the API's. */
+export declare enum CheckoutPaymentStatusEnum {
+    PENDING = "pending",
+    PAID = "paid",
+    EXPIRED = "expired",
+    LOCKED = "locked",
+    CANCELLED = "cancelled"
+}
+/** Where a method stands on this payment: payable, greyed with a note, or not built yet. */
+export declare enum MethodStateEnum {
+    AVAILABLE = "available",
+    MAINTENANCE = "maintenance",
+    SOON = "soon"
+}
+export declare enum MethodKindEnum {
+    MOBILE_MONEY = "mobile_money",
+    CARD = "card"
+}
+/** How the payer approves: a prompt on the phone, a one-time code, or card fields. Values are the backend's. */
+export declare enum MethodFlowEnum {
+    USSD_PUSH = "ussd_push",
+    OTP = "otp",
+    CARD_FIELDS = "card_fields"
+}
+/** The network a Mobile Money number belongs to, from its first digits. Values are logo names. */
+export declare enum MethodBrandEnum {
+    ORANGE = "orange",
+    MTN = "mtn",
+    MOOV = "moov"
+}
+/** Why Pay was refused. Values are the backend's. */
+export declare enum PayRefusalEnum {
+    CLOSED = "closed",
+    METHOD = "method",
+    PHONE = "phone",
+    /** An OTP method came without a valid code. */
+    CODE = "code"
+}
+/**
+ * What a provider's card fields page and the checkout tell each other through
+ * `postMessage`. The card itself never crosses: only whether it is complete,
+ * the page's height, and how a Pay went.
+ */
+export declare enum CardFieldsMessageEnum {
+    /** Page → checkout: `complete` says whether Pay can go. */
+    STATE = "card-fields:state",
+    /** Page → checkout: its content height, so the frame never scrolls. */
+    HEIGHT = "card-fields:height",
+    /** Checkout → page: Pay was pressed. */
+    SUBMIT = "card-fields:submit",
+    /** Page → checkout: the card is with the provider; the checkout waits for the status checks. */
+    DONE = "card-fields:done",
+    /** Page → checkout: Pay was refused (`reason`), or could not reach us (none). */
+    REFUSED = "card-fields:refused"
+}
+export declare enum CardFieldEnum {
+    NUMBER = "number",
+    EXPIRY = "expiry",
+    CVC = "cvc"
+}
+/** What a tester makes the Simulator answer. Values are the backend's. */
+export declare enum SimulatorOutcomeEnum {
+    APPROVED = "approved",
+    DECLINED = "declined",
+    INSUFFICIENT_FUNDS = "insufficient_funds",
+    NO_ACCOUNT = "no_account",
+    WRONG_PIN = "wrong_pin",
+    WRONG_CODE = "wrong_code",
+    PROVIDER_ERROR = "provider_error",
+    WRONG_AMOUNT = "wrong_amount",
+    APPROVED_LATE = "approved_late",
+    REVERSED = "reversed"
+}
+export declare enum PhoneErrorEnum {
+    START = "start",
+    SHORT = "short",
+    INVALID = "invalid",
+    EMPTY = "empty",
+    OPERATOR = "operator",
+    /** An international number of a country the payment is not offered in. */
+    COUNTRY = "country"
+}
+export declare enum SupportChannelEnum {
+    WHATSAPP = "whatsapp",
+    EMAIL = "email"
+}
+/** Values are the keys of `faqs` in the checkout catalog. */
+export declare enum FaqEnum {
+    NOT_RECEIVED = "not_received",
+    DEBITED = "debited"
+}
+/** Screens the payer cannot act on, each with its copy. Values are catalog keys. */
+export declare enum TerminalKindEnum {
+    EXPIRED = "expired",
+    CANCELLED = "cancelled",
+    LOCKED = "locked",
+    INVALID = "invalid",
+    NO_METHOD = "no_method"
+}
+export declare enum CheckoutButtonVariantEnum {
+    PRIMARY = "primary",
+    SECONDARY = "secondary",
+    /** Gives something up: cancelling the payment. */
+    DANGER = "danger"
+}
+/** Values are the `theme` an app may send. */
+export declare enum CheckoutThemeEnum {
+    LIGHT = "light",
+    DARK = "dark"
+}

package/dist/checkout-core/models/checkout.enum.js

@@ -0,0 +1,148 @@
+export var CheckoutScreenEnum;
+(function (CheckoutScreenEnum) {
+    CheckoutScreenEnum["LOADING"] = "loading";
+    CheckoutScreenEnum["FORM"] = "form";
+    CheckoutScreenEnum["SUBMITTING"] = "submitting";
+    CheckoutScreenEnum["WAITING"] = "waiting";
+    /** The last attempt failed: why, a retry and another method. */
+    CheckoutScreenEnum["FAILED"] = "failed";
+    CheckoutScreenEnum["SUCCESS"] = "success";
+    CheckoutScreenEnum["EXPIRED"] = "expired";
+    CheckoutScreenEnum["CANCELLED"] = "cancelled";
+    CheckoutScreenEnum["LOCKED"] = "locked";
+    CheckoutScreenEnum["INVALID"] = "invalid";
+    /** Every method went off since the link was made: nothing to pay with. */
+    CheckoutScreenEnum["NO_METHOD"] = "no_method";
+    CheckoutScreenEnum["REDIRECT"] = "redirect";
+})(CheckoutScreenEnum || (CheckoutScreenEnum = {}));
+/** Values are the `preferredTab` an app may send. */
+export var CheckoutTabEnum;
+(function (CheckoutTabEnum) {
+    CheckoutTabEnum["MOBILE_MONEY"] = "mobile_money";
+    CheckoutTabEnum["CARD"] = "card";
+})(CheckoutTabEnum || (CheckoutTabEnum = {}));
+/** GLOSSARY: Payment. Values are the API's. */
+export var CheckoutPaymentStatusEnum;
+(function (CheckoutPaymentStatusEnum) {
+    CheckoutPaymentStatusEnum["PENDING"] = "pending";
+    CheckoutPaymentStatusEnum["PAID"] = "paid";
+    CheckoutPaymentStatusEnum["EXPIRED"] = "expired";
+    CheckoutPaymentStatusEnum["LOCKED"] = "locked";
+    CheckoutPaymentStatusEnum["CANCELLED"] = "cancelled";
+})(CheckoutPaymentStatusEnum || (CheckoutPaymentStatusEnum = {}));
+/** Where a method stands on this payment: payable, greyed with a note, or not built yet. */
+export var MethodStateEnum;
+(function (MethodStateEnum) {
+    MethodStateEnum["AVAILABLE"] = "available";
+    MethodStateEnum["MAINTENANCE"] = "maintenance";
+    MethodStateEnum["SOON"] = "soon";
+})(MethodStateEnum || (MethodStateEnum = {}));
+export var MethodKindEnum;
+(function (MethodKindEnum) {
+    MethodKindEnum["MOBILE_MONEY"] = "mobile_money";
+    MethodKindEnum["CARD"] = "card";
+})(MethodKindEnum || (MethodKindEnum = {}));
+/** How the payer approves: a prompt on the phone, a one-time code, or card fields. Values are the backend's. */
+export var MethodFlowEnum;
+(function (MethodFlowEnum) {
+    MethodFlowEnum["USSD_PUSH"] = "ussd_push";
+    MethodFlowEnum["OTP"] = "otp";
+    MethodFlowEnum["CARD_FIELDS"] = "card_fields";
+})(MethodFlowEnum || (MethodFlowEnum = {}));
+/** The network a Mobile Money number belongs to, from its first digits. Values are logo names. */
+export var MethodBrandEnum;
+(function (MethodBrandEnum) {
+    MethodBrandEnum["ORANGE"] = "orange";
+    MethodBrandEnum["MTN"] = "mtn";
+    MethodBrandEnum["MOOV"] = "moov";
+})(MethodBrandEnum || (MethodBrandEnum = {}));
+/** Why Pay was refused. Values are the backend's. */
+export var PayRefusalEnum;
+(function (PayRefusalEnum) {
+    PayRefusalEnum["CLOSED"] = "closed";
+    PayRefusalEnum["METHOD"] = "method";
+    PayRefusalEnum["PHONE"] = "phone";
+    /** An OTP method came without a valid code. */
+    PayRefusalEnum["CODE"] = "code";
+})(PayRefusalEnum || (PayRefusalEnum = {}));
+/**
+ * What a provider's card fields page and the checkout tell each other through
+ * `postMessage`. The card itself never crosses: only whether it is complete,
+ * the page's height, and how a Pay went.
+ */
+export var CardFieldsMessageEnum;
+(function (CardFieldsMessageEnum) {
+    /** Page → checkout: `complete` says whether Pay can go. */
+    CardFieldsMessageEnum["STATE"] = "card-fields:state";
+    /** Page → checkout: its content height, so the frame never scrolls. */
+    CardFieldsMessageEnum["HEIGHT"] = "card-fields:height";
+    /** Checkout → page: Pay was pressed. */
+    CardFieldsMessageEnum["SUBMIT"] = "card-fields:submit";
+    /** Page → checkout: the card is with the provider; the checkout waits for the status checks. */
+    CardFieldsMessageEnum["DONE"] = "card-fields:done";
+    /** Page → checkout: Pay was refused (`reason`), or could not reach us (none). */
+    CardFieldsMessageEnum["REFUSED"] = "card-fields:refused";
+})(CardFieldsMessageEnum || (CardFieldsMessageEnum = {}));
+export var CardFieldEnum;
+(function (CardFieldEnum) {
+    CardFieldEnum["NUMBER"] = "number";
+    CardFieldEnum["EXPIRY"] = "expiry";
+    CardFieldEnum["CVC"] = "cvc";
+})(CardFieldEnum || (CardFieldEnum = {}));
+/** What a tester makes the Simulator answer. Values are the backend's. */
+export var SimulatorOutcomeEnum;
+(function (SimulatorOutcomeEnum) {
+    SimulatorOutcomeEnum["APPROVED"] = "approved";
+    SimulatorOutcomeEnum["DECLINED"] = "declined";
+    SimulatorOutcomeEnum["INSUFFICIENT_FUNDS"] = "insufficient_funds";
+    SimulatorOutcomeEnum["NO_ACCOUNT"] = "no_account";
+    SimulatorOutcomeEnum["WRONG_PIN"] = "wrong_pin";
+    SimulatorOutcomeEnum["WRONG_CODE"] = "wrong_code";
+    SimulatorOutcomeEnum["PROVIDER_ERROR"] = "provider_error";
+    SimulatorOutcomeEnum["WRONG_AMOUNT"] = "wrong_amount";
+    SimulatorOutcomeEnum["APPROVED_LATE"] = "approved_late";
+    SimulatorOutcomeEnum["REVERSED"] = "reversed";
+})(SimulatorOutcomeEnum || (SimulatorOutcomeEnum = {}));
+export var PhoneErrorEnum;
+(function (PhoneErrorEnum) {
+    PhoneErrorEnum["START"] = "start";
+    PhoneErrorEnum["SHORT"] = "short";
+    PhoneErrorEnum["INVALID"] = "invalid";
+    PhoneErrorEnum["EMPTY"] = "empty";
+    PhoneErrorEnum["OPERATOR"] = "operator";
+    /** An international number of a country the payment is not offered in. */
+    PhoneErrorEnum["COUNTRY"] = "country";
+})(PhoneErrorEnum || (PhoneErrorEnum = {}));
+export var SupportChannelEnum;
+(function (SupportChannelEnum) {
+    SupportChannelEnum["WHATSAPP"] = "whatsapp";
+    SupportChannelEnum["EMAIL"] = "email";
+})(SupportChannelEnum || (SupportChannelEnum = {}));
+/** Values are the keys of `faqs` in the checkout catalog. */
+export var FaqEnum;
+(function (FaqEnum) {
+    FaqEnum["NOT_RECEIVED"] = "not_received";
+    FaqEnum["DEBITED"] = "debited";
+})(FaqEnum || (FaqEnum = {}));
+/** Screens the payer cannot act on, each with its copy. Values are catalog keys. */
+export var TerminalKindEnum;
+(function (TerminalKindEnum) {
+    TerminalKindEnum["EXPIRED"] = "expired";
+    TerminalKindEnum["CANCELLED"] = "cancelled";
+    TerminalKindEnum["LOCKED"] = "locked";
+    TerminalKindEnum["INVALID"] = "invalid";
+    TerminalKindEnum["NO_METHOD"] = "no_method";
+})(TerminalKindEnum || (TerminalKindEnum = {}));
+export var CheckoutButtonVariantEnum;
+(function (CheckoutButtonVariantEnum) {
+    CheckoutButtonVariantEnum["PRIMARY"] = "primary";
+    CheckoutButtonVariantEnum["SECONDARY"] = "secondary";
+    /** Gives something up: cancelling the payment. */
+    CheckoutButtonVariantEnum["DANGER"] = "danger";
+})(CheckoutButtonVariantEnum || (CheckoutButtonVariantEnum = {}));
+/** Values are the `theme` an app may send. */
+export var CheckoutThemeEnum;
+(function (CheckoutThemeEnum) {
+    CheckoutThemeEnum["LIGHT"] = "light";
+    CheckoutThemeEnum["DARK"] = "dark";
+})(CheckoutThemeEnum || (CheckoutThemeEnum = {}));

package/dist/checkout-core/models/checkout.interface.d.ts

@@ -0,0 +1,417 @@
+import type { CardFieldsMessageEnum, CheckoutPaymentStatusEnum, CheckoutScreenEnum, CheckoutTabEnum, CheckoutThemeEnum, MethodBrandEnum, MethodFlowEnum, MethodKindEnum, MethodStateEnum, PayRefusalEnum, PhoneErrorEnum, SimulatorOutcomeEnum, SupportChannelEnum } from './checkout.enum.js';
+import type { AttemptStatusEnum, CountryEnum, CurrencyEnum, FailureReasonEnum, LangEnum, ProviderLogoEnum } from './domain.enum.js';
+export interface CheckoutApp {
+    name: string;
+    color: string;
+    logoUrl: string | null;
+    termsUrl: string | null;
+    privacyUrl: string | null;
+    supportEmail: string | null;
+    /** E.164. */
+    supportWhatsapp: string | null;
+}
+export interface CheckoutItem {
+    name: string;
+    quantity: number;
+    /** Minor units. */
+    unitAmount: number;
+}
+/** A payment method this payment can be paid with, in the admin's order. */
+export interface CheckoutMethod {
+    id: string;
+    name: string;
+    kind: MethodKindEnum;
+    country: CountryEnum;
+    /** The network that runs it ("Orange Cameroun"). */
+    network: string;
+    flow: MethodFlowEnum;
+    /** The code a payer dials to see payments waiting for approval. */
+    pendingCode: string | null;
+    /** OTP methods: what the payer dials to get a payment code for this amount. */
+    otpCode: string | null;
+    /** Card methods: the provider's page hosting its card fields, shown in an iframe. */
+    cardFieldsPath: string | null;
+    logos: Array<ProviderLogoEnum>;
+    state: MethodStateEnum;
+    /** Why it is in maintenance, for the payer. */
+    note: string | null;
+}
+/**
+ * A paid card as its provider reported it: never more than the last 4
+ * digits. The brand is the provider's own word, whatever the network.
+ */
+export interface CardSummary {
+    brand: string;
+    last4: string;
+}
+export interface CheckoutAttempt {
+    reference: string;
+    method: string;
+    /** As the payer read it when paying. */
+    methodName: string;
+    logos: Array<ProviderLogoEnum>;
+    flow: MethodFlowEnum;
+    pendingCode: string | null;
+    status: AttemptStatusEnum;
+    failureReason: FailureReasonEnum | null;
+    /** E.164; a card has none. */
+    phone: string | null;
+    /** A paid card: its brand and last 4 digits. */
+    card: CardSummary | null;
+    startedAt: number;
+    /** A test attempt the Simulator took: the tester picks its outcome. */
+    simulated: boolean;
+}
+export interface CheckoutPayer {
+    name: string | null;
+    phone: string | null;
+    email: string | null;
+}
+/** One payment as the checkout shows it (`checkout.queries.get`). */
+export interface CheckoutView {
+    id: string;
+    status: CheckoutPaymentStatusEnum;
+    test: boolean;
+    /** Minor units. */
+    amount: number;
+    currency: CurrencyEnum;
+    orderRef: string | null;
+    items: Array<CheckoutItem>;
+    returnUrl: string;
+    expiresAt: number;
+    paidAt: number | null;
+    payer: CheckoutPayer;
+    /** The app's hint for the payer's country. */
+    country: CountryEnum | null;
+    language: LangEnum | null;
+    theme: CheckoutThemeEnum | null;
+    preferredMethod: string | null;
+    preferredTab: CheckoutTabEnum | null;
+    app: CheckoutApp;
+    methods: Array<CheckoutMethod>;
+    /** Payer-caused failures it still takes before it locks, out of `maxAttempts`. */
+    attemptsLeft: number;
+    maxAttempts: number;
+    attempt: CheckoutAttempt | null;
+    /**
+     * Where the checkout is served, without a trailing slash: the payment
+     * sheet loads card fields pages (`cardFieldsPath`) from it.
+     */
+    siteUrl: string;
+}
+/** Where the request came from, for picking the payer's country. */
+export interface CountryClues {
+    /** From the proxy's country header, when it sends one. */
+    ipCountry: string | null;
+    /** Browser languages in preference order (`fr-CM`). */
+    languages: Array<string>;
+}
+/** A greyed row on the Card tab for a wallet no provider offers yet. */
+export interface ComingSoonWallet {
+    /** Catalog key under `wallets` and logo name. */
+    id: ProviderLogoEnum;
+}
+export interface OperatorDetection {
+    /** The operator the number belongs to, once enough digits say so. */
+    operator: MethodBrandEnum | null;
+    /** Enough digits were typed and no known operator matches. */
+    unrecognized: boolean;
+}
+export interface PhoneInputs {
+    country: CountryEnum;
+    /** Digits of the national number, no dial code and no spaces. */
+    digits: string;
+    /** A full international number of a country the payment is not offered in. */
+    foreign: boolean;
+    touched: boolean;
+    focused: boolean;
+    submitTried: boolean;
+}
+export interface PhoneStatus {
+    error: PhoneErrorEnum | null;
+    valid: boolean;
+    operator: MethodBrandEnum | null;
+}
+/** What the payer typed, read: its country and national digits. */
+export interface TypedNumber {
+    country: CountryEnum;
+    digits: string;
+    /** A `+…` number kept as typed while its country is unknown or not offered. */
+    pending: string | null;
+}
+export interface PhoneNumberOptions {
+    country: CountryEnum;
+    /** Countries of this payment's Mobile Money methods. */
+    countries: Array<CountryEnum>;
+    /** The payer typed or pasted a full number of another offered country. */
+    onCountryChange: (country: CountryEnum) => void;
+}
+/** The Mobile Money number without its field: each platform draws and wires its own input. */
+export interface PhoneNumber {
+    /** What the field shows: the number grouped the country's way. */
+    value: string;
+    /**
+     * The field's new text and where its caret was; answers where the caret
+     * goes in the grouped number, or null to leave it (an international number).
+     */
+    type: (text: string, caret: number) => number | null;
+    /** E.164, empty until the number is complete. */
+    e164: string;
+    dial: string;
+    placeholder: string;
+    status: PhoneStatus;
+    focused: boolean;
+    onFocus: () => void;
+    onBlur: () => void;
+    /** Marks the field as submitted, so its error shows. */
+    reject: () => void;
+    /** The app's number for the payer, when it is of the page's country. */
+    fill: (e164: string) => void;
+}
+/** What the payer did on this page; the payment itself comes from the gateway. */
+export interface CheckoutUi {
+    tab: CheckoutTabEnum;
+    country: CountryEnum;
+    /** The Mobile Money method picked, if any. */
+    method: string | null;
+    /** The payment code typed for an OTP method; cleared when the method changes. */
+    code: string;
+    /** A card method's fields say the card is complete. */
+    cardComplete: boolean;
+    /** Pay went to the card fields page: the form stays until it says how it went. */
+    cardPaying: boolean;
+    pickerOpen: boolean;
+    summaryOpen: boolean;
+    submitting: boolean;
+    /** An attempt the payer walked away from: the form shows again. */
+    dismissed: string | null;
+    redirecting: boolean;
+}
+/** Everything the screens show that follows from the payment and the page, worked out once. */
+export interface CheckoutDerived {
+    screen: CheckoutScreenEnum;
+    /** Countries with Mobile Money methods, in the admin's order. */
+    countries: Array<CountryEnum>;
+    wallets: Array<CheckoutMethod>;
+    cards: Array<CheckoutMethod>;
+    /** The picked method, while it can still be used. */
+    selected: CheckoutMethod | null;
+    canPay: boolean;
+    /** The number belongs to another method of the country than the one picked. */
+    mismatch: CheckoutMethod | null;
+    /** After a failure: another method of the same country the payer can use now. */
+    suggestion: CheckoutMethod | null;
+}
+export interface CheckoutCoreActions {
+    toggleSummary: () => void;
+    setTab: (tab: CheckoutTabEnum) => void;
+    setCountry: (country: CountryEnum) => void;
+    selectMethod: (method: CheckoutMethod) => void;
+    /** A greyed wallet no provider offers yet was tapped. */
+    comingSoon: (name: string) => void;
+    openPicker: () => void;
+    switchToDetected: () => void;
+    pay: () => void;
+    /** The failed attempt again: same method, same number. An OTP method asks for a new code first. */
+    retry: () => void;
+    setCode: (code: string) => void;
+    /** The phone could not open its dialler on the OTP method's code: dial it by hand. */
+    cannotDial: () => void;
+    /** Leaves the failure screen for the suggested method, or the list. */
+    useAnother: () => void;
+    /** "Didn't get it?": the prompt again. */
+    resend: () => void;
+    cancel: () => void;
+    returnNow: () => void;
+    stayHere: () => void;
+    openHelp: () => void;
+    closeHelp: () => void;
+    copyReference: () => void;
+    downloadReceipt: () => void;
+    simulate: (outcome: SimulatorOutcomeEnum) => void;
+}
+/** The checkout's state and actions, the same on the web page and in the payment sheet. */
+export interface CheckoutCore {
+    /** Null for a link that matches no payment. */
+    view: CheckoutView | null;
+    ui: CheckoutUi;
+    derived: CheckoutDerived;
+    phone: PhoneNumber;
+    /** Seconds left on the waiting screen's clock. */
+    waitLeft: number;
+    /** Seconds before the success screen sends the payer back, null once stopped. */
+    returnLeft: number | null;
+    helpOpen: boolean;
+    toastMessage: string | null;
+    copied: boolean;
+    /** The Branding tab's preview: nothing can be paid. */
+    preview: boolean;
+    /** The card fields' content height, as their page last said; null until it loaded. */
+    cardHeight: number | null;
+    actions: CheckoutCoreActions;
+}
+/**
+ * What only the platform can do, handed to the controller. Pass one stable
+ * object: a new one each render subscribes again.
+ */
+export interface CheckoutPlatform {
+    /** Calls `listener` each time the payer comes back to the page or the app; answers how to stop. */
+    onReturn: (listener: () => void) => () => void;
+    copyText: (text: string) => void;
+    /** Leaves for the app's return URL. */
+    openUrl: (url: string) => void;
+    /** Calls `listener` with each message the card fields page sends; answers how to stop. */
+    onCardMessage: (listener: (message: CardFieldsMessage) => void) => () => void;
+    /** Tells the card fields page that Pay was pressed. */
+    submitCard: () => void;
+    /** Hands the receipt to the payer as a text file. */
+    saveReceipt: (fileName: string, text: string) => void;
+    /** Pay found the number wrong: draw the payer's eye to the field. */
+    onPhoneRejected: () => void;
+}
+export interface CheckoutControllerOptions {
+    clues: CountryClues;
+    /** Null on the Branding tab's preview: nothing is paid there. */
+    mutations: CheckoutMutations | null;
+    platform: CheckoutPlatform;
+}
+/** What Pay answers: refused with a reason, or an attempt started. */
+export interface PayResult {
+    ok: boolean;
+    reason?: PayRefusalEnum;
+}
+/** The gateway calls the page makes; none on the Branding tab's preview. */
+export interface CheckoutMutations {
+    pay: (args: {
+        paymentId: string;
+        method: string;
+        phone: string;
+    }) => Promise<PayResult>;
+    /** OTP methods: Pay with the payment code, which the server never stores. */
+    payWithCode: (args: {
+        paymentId: string;
+        method: string;
+        phone: string;
+        otp: string;
+    }) => Promise<PayResult>;
+    checkNow: (args: {
+        paymentId: string;
+    }) => Promise<null>;
+    /** The payer opened the link; the funnel counts the first time only. */
+    open: (args: {
+        paymentId: string;
+    }) => Promise<null>;
+    cancel: (args: {
+        paymentId: string;
+    }) => Promise<null>;
+    resend: (args: {
+        paymentId: string;
+    }) => Promise<{
+        ok: boolean;
+    }>;
+    simulate: (args: {
+        paymentId: string;
+        outcome: SimulatorOutcomeEnum;
+    }) => Promise<null>;
+}
+/** What the payer typed in the Simulator's stand-in card fields; it never leaves that page. */
+export interface CardEntry {
+    number: string;
+    expiry: string;
+    cvc: string;
+}
+/** A card fields page's address: the payment, its method, and the look of the checkout that shows it. */
+export interface CardFieldsSearch {
+    payment?: string;
+    method?: string;
+    /** The app colour, a hex code. */
+    color?: string;
+    theme?: CheckoutThemeEnum.DARK;
+}
+/** The Simulator's stand-in card fields page, from its address. */
+export interface SimulatorCardFieldsProps {
+    /** Null when the page is opened on its own: nothing can be paid. */
+    paymentId: string | null;
+    method: string | null;
+    /** The app colour, a hex code. */
+    color: string | null;
+    dark: boolean;
+}
+/** What a card fields page and the checkout send each other (`CardFieldsMessageEnum`). */
+export interface CardFieldsMessage {
+    type: CardFieldsMessageEnum;
+    complete?: boolean;
+    height?: number;
+    reason?: PayRefusalEnum;
+}
+/** How a Pay goes: the number, and the payment code of an OTP method. */
+export interface PayVia {
+    phone: string;
+    otp?: string;
+}
+/** The Convex calls of the stand-in card fields page. */
+export interface SimulatorCardFieldsCalls {
+    startCard: (args: {
+        paymentId: string;
+        method: string;
+    }) => Promise<{
+        ok: true;
+        reference: string;
+        providerReference: string | null;
+    } | {
+        ok: false;
+        reason: PayRefusalEnum;
+    }>;
+    receiveCard: (args: {
+        reference: string;
+        brand: string;
+        last4: string;
+    }) => Promise<null>;
+    checkNow: (args: {
+        paymentId: string;
+    }) => Promise<null>;
+}
+/** What each way of approving changes on the screens. */
+export interface FlowTraits {
+    /** The tab its methods are on. */
+    tab: CheckoutTabEnum;
+    /** A prompt on the phone: the waiting screen's steps and "send it again". */
+    prompt: boolean;
+    /** What the Simulator offers that this flow's payer cannot do. */
+    hiddenOutcomes: Array<SimulatorOutcomeEnum>;
+}
+/** The checkout's themed colours (`--ck-*` in `checkout.css`), for a platform without the stylesheet. */
+export interface CheckoutColors {
+    page: string;
+    surface: string;
+    tabOn: string;
+    fill: string;
+    fill2: string;
+    fill3: string;
+    ink: string;
+    inkStrong: string;
+    ink2: string;
+    muted: string;
+    faint: string;
+    line: string;
+    line2: string;
+    line3: string;
+    line4: string;
+    danger: string;
+    dangerSoft: string;
+    warnSoft: string;
+    warnLine: string;
+    warnInk: string;
+    warnInk2: string;
+    successInk: string;
+}
+export interface CheckoutPreviewApp {
+    name: string;
+    color: string;
+    logoUrl: string | null;
+}
+export interface SupportContact {
+    channel: SupportChannelEnum;
+    value: string;
+    href: string;
+}

package/dist/checkout-core/models/checkout.interface.js

@@ -0,0 +1 @@
+export {};