@agent-cards/sdk 0.23.21 → 0.23.22

package/dist/payrexx.d.ts

@@ -0,0 +1,91 @@
+export declare const PAYREXX_PSP: "payrexx";
+/** The capability a build declares to be served Payrexx's recognizer (payment-core PAYREXX_CAPABILITY). */
+export declare const PAYREXX_CAPABILITY: "payrexx_card_frame";
+/** The reason a checkout reads when a 3-D Secure send of the placeholder card fails in the browser. */
+export declare const PAYREXX_RESEND_REASON: "unsupported_payrexx_card_resend";
+/** The 3-D Secure sends one approval covers, in the page's order (payment-core PAYREXX_FOLLOW_UP_KINDS). */
+export type PayrexxFollowUpKind = 'authentication' | 'post_authentication';
+/**
+ * Whether a request is a POST to Payrexx's card frame URL whose body sends the card again for a 3-D Secure step
+ * (payment-core payrexxBodyVerdict: payrexx_three_ds_resend). `readBody` is called only for a POST to the frame URL,
+ * and a reader that throws, or a body nobody could read, reads as no 3-D Secure send.
+ */
+export declare function isPayrexxResend(url: string, method: string, readBody: () => string | null): boolean;
+/**
+ * A 3-D Secure send the cardholder's device did not answer with Payrexx's own answer. `reason` is the API's word for
+ * it: `not_picked_up` (no device started it in time: the Vault page was closed or asleep), `not_sent` (the device
+ * refused it before the card left), `no_answer`, `answer_withheld` (Payrexx's answer carried the card),
+ * `answer_refused`, `answer_late`, `response_expired`, or the API's refusal code when it did not take the send at all
+ * (`follow_up_refused`, `follow_up_not_covered`, `follow_up_window_closed`). `cardSent` says whether the card may
+ * have reached Payrexx: false only when the API confirmed it never left the device. Nothing in it names the request,
+ * the card or Payrexx's answer.
+ */
+export declare class PayrexxFollowUpError extends Error {
+    readonly reason: string;
+    readonly cardSent: boolean;
+    readonly authorizationId: string;
+    constructor(reason: string, cardSent: boolean, authorizationId: string);
+}
+/** A send this attachment claimed: the approval it goes under, its kind, the request to send, and how it ended. */
+export interface PayrexxFollowUpClaim {
+    readonly authorizationId: string;
+    readonly kind: PayrexxFollowUpKind;
+    readonly until: number;
+    readonly request: {
+        url: string;
+        method: 'POST';
+        headers: Record<string, string>;
+        body: string;
+    };
+    /** Record the answer the page received, or null when the send failed. */
+    settle(answer: {
+        status: number;
+        text: string;
+    } | null): void;
+}
+/**
+ * What one attachment keeps of its approved Payrexx card request: the request and Payrexx's answer as the page received
+ * them, until when the API said the approval covers sends after it, and the sends it claimed since, in order. Only a
+ * card request whose answer started 3-D Secure (payment-core payrexxAnswerOutcome: pending three_ds) and whose read
+ * named that window (`followUpsUntil`) is kept. Any later Payrexx card request handed over replaces it, a send the
+ * window has passed is never claimed, and once a send is refused or fails the attachment stops (stop()): nothing after
+ * it is claimed, a later approval included.
+ */
+export declare class PayrexxFollowUps {
+    private parent;
+    private sent;
+    private stopped;
+    /** After a refused or failed send: no later request on this attachment is claimed. */
+    stop(): void;
+    /**
+     * The approval the remembered card request went under, or null when none is remembered. The gate sends nothing
+     * unless the checkout's own state names this same approval.
+     */
+    get authorizationId(): string | null;
+    /**
+     * As the adapter hands an approved card request's answer to the page: before the answer lands, since the page may
+     * start 3-D Secure at once. Every Payrexx card request handed over clears what an earlier one left; only one whose
+     * answer started 3-D Secure, under a read that named the window, is kept.
+     */
+    remember(request: {
+        url: string;
+        body: string;
+    }, replay: {
+        mode?: string;
+        authorizationId: string;
+        status: number;
+        body: string;
+        followUpsUntil?: string;
+    }): void;
+    /**
+     * The claim for a paused 3-D Secure send the remembered approval covers, or null: no approval covers sends here, its
+     * window has passed, or payment-core's rule refuses the send against the sends already claimed. Synchronous, and it
+     * reserves the send, so two requests can never both be claimed as the next one.
+     */
+    claim(request: {
+        url: string;
+        method: string;
+        headers: Record<string, string>;
+        body: string | null;
+    }, now?: number): PayrexxFollowUpClaim | null;
+}

package/dist/payrexx.generated.d.ts

@@ -0,0 +1,91 @@
+declare var PAYREXX_PSP: string;
+declare var PAYREXX_CAPABILITY: string;
+declare var PAYREXX_OPERATION: string;
+declare var PAYREXX_FRAME_HOST: string;
+declare var PAYREXX_PAY_PSP_ID: string;
+declare var PAYREXX_BODY_KEYS: readonly string[];
+declare var PAYREXX_REFUSAL_CODES: readonly string[];
+declare function payrexxFrameTarget(url: any): Readonly<{
+    pspId: string;
+    lang: string;
+}> | null;
+declare function isPayrexxFrameUrl(url: any): boolean;
+declare function payrexxBodyVerdict(body: any): Readonly<{
+    verdict: "refuse";
+    code: any;
+}> | Readonly<{
+    verdict: "continue";
+}> | Readonly<{
+    verdict: "card";
+}>;
+declare function payrexxGateVerdict(url: any, body: any): Readonly<{
+    verdict: "refuse";
+    code: any;
+}> | Readonly<{
+    verdict: "continue";
+}> | Readonly<{
+    verdict: "card";
+}>;
+declare function payrexxRequestRefusal(request: any): any;
+declare function isPayrexxDeviceRequest(template: any, body: any): boolean;
+declare function payrexxInstance(body: any): any;
+declare var PAYREXX_REVIEWED_INSTANCES: readonly string[];
+declare function payrexxInstanceRefusal(instance: any, instances?: readonly string[]): "payrexx_instance_unreviewed" | null;
+declare function payrexxRequestAmount(body: any): Readonly<{
+    amountCents: number;
+    currency: any;
+}> | null;
+declare function injectPayrexxCard(body: any, card: any): {
+    body: string;
+    where: any[];
+};
+declare function payrexxAnswerOutcome(status: any, text: any, card: any): {
+    outcome: string;
+    code: string;
+    reason?: undefined;
+    body?: undefined;
+    pending?: undefined;
+} | {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+    body?: undefined;
+    pending?: undefined;
+} | {
+    outcome: string;
+    body: string;
+    code?: undefined;
+    reason?: undefined;
+    pending?: undefined;
+} | {
+    outcome: string;
+    body: string;
+    pending: string;
+    code?: undefined;
+    reason?: undefined;
+};
+declare function payrexxRefusalCode(text: any): "payrexx_declined" | "payrexx_three_ds_error" | "payrexx_three_ds_declined" | null;
+declare var PAYREXX_FOLLOW_UP_KINDS: readonly string[];
+declare var PAYREXX_FOLLOW_UP_LIMITS: Readonly<{
+    authentication: 1;
+    post_authentication: 1;
+}>;
+declare var PAYREXX_FOLLOW_UP_MAX: number;
+declare var PAYREXX_FOLLOW_UP_WINDOW_MS: number;
+declare var PAYREXX_FOLLOW_UP_IDLE_MS: number;
+declare var PAYREXX_FOLLOW_UP_CHALLENGE_MS: number;
+declare var PAYREXX_FOLLOW_UP_BODY_LIMIT: number;
+declare var PAYREXX_FOLLOW_UP_ANSWER_LIMIT: number;
+declare var PAYREXX_FOLLOW_UP_REFUSALS: readonly string[];
+declare function payrexxFollowUpVerdict(input: any): Readonly<{
+    ok: false;
+    refusal: any;
+}> | Readonly<{
+    ok: true;
+    kind: string | undefined;
+    slot: 1;
+}>;
+declare function payrexxFollowUpIdleMs(kind: any, answerText: any): number;
+declare function payrexxFollowUpAnswerRefusal(answerText: any): "answer_unreadable" | "card_in_answer" | null;
+declare function payrexxRefusalMessage(code: any): any;
+export { PAYREXX_BODY_KEYS, PAYREXX_CAPABILITY, PAYREXX_FOLLOW_UP_ANSWER_LIMIT, PAYREXX_FOLLOW_UP_BODY_LIMIT, PAYREXX_FOLLOW_UP_CHALLENGE_MS, PAYREXX_FOLLOW_UP_IDLE_MS, PAYREXX_FOLLOW_UP_KINDS, PAYREXX_FOLLOW_UP_LIMITS, PAYREXX_FOLLOW_UP_MAX, PAYREXX_FOLLOW_UP_REFUSALS, PAYREXX_FOLLOW_UP_WINDOW_MS, PAYREXX_FRAME_HOST, PAYREXX_OPERATION, PAYREXX_PAY_PSP_ID, PAYREXX_PSP, PAYREXX_REFUSAL_CODES, PAYREXX_REVIEWED_INSTANCES, injectPayrexxCard, isPayrexxDeviceRequest, isPayrexxFrameUrl, payrexxAnswerOutcome, payrexxBodyVerdict, payrexxFollowUpAnswerRefusal, payrexxFollowUpIdleMs, payrexxFollowUpVerdict, payrexxFrameTarget, payrexxGateVerdict, payrexxInstance, payrexxInstanceRefusal, payrexxRefusalCode, payrexxRefusalMessage, payrexxRequestAmount, payrexxRequestRefusal };