@tagadapay/plugin-sdk 3.1.12 → 3.1.24

package/dist/v2/core/resources/payments.d.ts

@@ -3,18 +3,19 @@
  * Axios-based API client for payment endpoints
  */
 import { ApiClient } from './apiClient';
+import type { Order } from '../types';
 export interface Payment {
     id: string;
     status: string;
     subStatus: string;
-    requireAction: 'none' | 'redirect' | 'error' | 'radar';
+    requireAction: 'none' | 'redirect' | 'redirect_to_payment' | 'error' | 'radar' | 'stripe_express_checkout';
     requireActionData?: {
-        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar';
+        type: 'redirect' | 'redirect_to_payment' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar' | 'kesspay_auth' | 'trustflow_auth' | 'mastercard_auth' | 'stripe_express_checkout';
         url?: string;
         processed: boolean;
         processorId?: string;
         metadata?: {
-            type: 'redirect' | 'stripe_radar' | 'finix_radar';
+            type: 'redirect' | 'redirect_to_payment' | 'stripe_radar' | 'finix_radar';
             redirect?: {
                 redirectUrl: string;
                 returnUrl: string;
@@ -31,6 +32,10 @@ export interface Payment {
                 orderId?: string;
                 publishableKey?: string;
             };
+            stripeExpressCheckout?: {
+                clientSecret: string;
+                publishableKey?: string;
+            };
             provider?: string;
             isTest?: boolean;
         };
@@ -42,12 +47,15 @@ export interface Payment {
     order?: {
         id: string;
         checkoutSessionId: string;
+        amount?: number;
+        currency?: string;
+        [key: string]: unknown;
     };
 }
 export interface PaymentResponse {
     paymentId: string;
     payment: Payment;
-    order?: any;
+    order?: Order | null;
 }
 export interface PaymentInstrumentResponse {
     id: string;
@@ -94,6 +102,16 @@ export interface PaymentOptions {
      * If neither is set, the store's selectedPaymentFlowId will be used
      */
     paymentFlowId?: string;
+    /**
+     * For alternative payment methods (APM)
+     * Processor ID to use for the payment
+     */
+    processorId?: string;
+    /**
+     * For alternative payment methods (APM)
+     * Payment method type (e.g., 'klarna', 'afterpay', 'paypal')
+     */
+    paymentMethod?: string;
     /** @deprecated Use onPaymentSuccess instead - this will be removed in v3 */
     onSuccess?: (response: PaymentResponse) => void;
     /** @deprecated Use onPaymentFailed instead - this will be removed in v3 */
@@ -138,28 +156,83 @@ export interface ApplePayToken {
         brand: string;
     };
 }
+/** Token response from BasisTheory SDK */
+export interface BasisTheoryTokenResponse {
+    id: string;
+    type: string;
+    enrichments?: {
+        cardDetails?: {
+            bin?: string;
+            last4?: string;
+        };
+    };
+}
+/** External BasisTheory SDK instance shape (from @basis-theory/basis-theory-react) */
+export interface BasisTheoryInstance {
+    tokens: {
+        create(data: Record<string, unknown>): Promise<BasisTheoryTokenResponse>;
+    };
+}
+export interface GooglePayToken {
+    id: string;
+    type: string;
+    card: {
+        bin: string;
+        last4: string;
+        expiration_month: number;
+        expiration_year: number;
+        brand: string;
+    };
+    details?: {
+        auth_method?: string;
+        [key: string]: unknown;
+    };
+}
+export interface PaymentInstrumentInput {
+    type: string;
+    token?: string;
+    card?: {
+        maskedCardNumber?: string;
+        expirationMonth?: number;
+        expirationYear?: number;
+        bin?: string;
+        last4?: string;
+        brand?: string;
+    };
+    dpanType?: string;
+    authMethod?: string;
+    provider?: string;
+    paymentMethod?: string;
+    processorId?: string;
+    [key: string]: unknown;
+}
 export declare class PaymentsResource {
     private apiClient;
     constructor(apiClient: ApiClient);
     /**
      * Create payment instrument
      */
-    createPaymentInstrument(paymentInstrumentData: any): Promise<PaymentInstrumentResponse>;
+    createPaymentInstrument(paymentInstrumentData: PaymentInstrumentInput): Promise<PaymentInstrumentResponse>;
     /**
      * Create card payment instrument
      */
-    createCardPaymentInstrument(basisTheory: any, // BasisTheory instance from @basis-theory/basis-theory-react
-    cardData: CardPaymentMethod): Promise<PaymentInstrumentResponse>;
+    createCardPaymentInstrument(basisTheory: BasisTheoryInstance | undefined, cardData: CardPaymentMethod): Promise<PaymentInstrumentResponse>;
     /**
      * Create Apple Pay payment instrument
      */
-    createApplePayPaymentInstrument(basisTheory: any, // BasisTheory instance from @basis-theory/basis-theory-react
-    applePayToken: ApplePayToken): Promise<PaymentInstrumentResponse>;
+    createApplePayPaymentInstrument(basisTheory: BasisTheoryInstance | undefined, applePayToken: ApplePayToken): Promise<PaymentInstrumentResponse>;
     /**
      * Create Google Pay payment instrument
      */
-    createGooglePayPaymentInstrument(basisTheory: any, // BasisTheory instance from @basis-theory/basis-theory-react
-    googlePayToken: any): Promise<PaymentInstrumentResponse>;
+    createGooglePayPaymentInstrument(basisTheory: BasisTheoryInstance | undefined, googlePayToken: GooglePayToken): Promise<PaymentInstrumentResponse>;
+    /**
+     * Create APM payment instrument (Klarna, Afterpay, PayPal, etc.)
+     */
+    createApmPaymentInstrument(apmData: {
+        provider: string;
+        paymentMethod: string;
+        processorId: string;
+    }): Promise<PaymentInstrumentResponse>;
     /**
      * Helper function to format expiry date
      */
@@ -171,6 +244,9 @@ export declare class PaymentsResource {
         initiatedBy?: 'customer' | 'merchant';
         source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
         paymentFlowId?: string;
+        processorId?: string;
+        paymentMethod?: string;
+        isExpress?: boolean;
     }): Promise<PaymentResponse>;
     /**
      * Get card payment instruments for customer
@@ -200,7 +276,7 @@ export declare class PaymentsResource {
         transactionId?: string;
         message?: string;
         success?: boolean;
-        error?: any;
+        error?: string;
     }>;
     saveRadarSession(data: {
         orderId?: string;
@@ -226,5 +302,5 @@ export declare class PaymentsResource {
         paymentId: string;
         status: 'succeeded' | 'failed' | 'pending';
         paymentIntentId: string;
-    }): Promise<any>;
+    }): Promise<Payment>;
 }

package/dist/v2/core/resources/payments.js

@@ -17,8 +17,7 @@ export class PaymentsResource {
     /**
      * Create card payment instrument
      */
-    async createCardPaymentInstrument(basisTheory, // BasisTheory instance from @basis-theory/basis-theory-react
-    cardData) {
+    async createCardPaymentInstrument(basisTheory, cardData) {
         if (!basisTheory) {
             throw new Error('Payment processor not initialized');
         }
@@ -55,8 +54,7 @@ export class PaymentsResource {
     /**
      * Create Apple Pay payment instrument
      */
-    async createApplePayPaymentInstrument(basisTheory, // BasisTheory instance from @basis-theory/basis-theory-react
-    applePayToken) {
+    async createApplePayPaymentInstrument(basisTheory, applePayToken) {
         if (!basisTheory) {
             throw new Error('Payment processor not initialized');
         }
@@ -81,9 +79,7 @@ export class PaymentsResource {
     /**
      * Create Google Pay payment instrument
      */
-    async createGooglePayPaymentInstrument(basisTheory, // BasisTheory instance from @basis-theory/basis-theory-react
-    googlePayToken // Token from Basis Theory Google Pay tokenization
-    ) {
+    async createGooglePayPaymentInstrument(basisTheory, googlePayToken) {
         if (!basisTheory) {
             throw new Error('Payment processor not initialized');
         }
@@ -106,6 +102,21 @@ export class PaymentsResource {
         const response = await this.apiClient.post('/api/v1/payment/create-payment-instrument', { paymentInstrumentData });
         return response;
     }
+    /**
+     * Create APM payment instrument (Klarna, Afterpay, PayPal, etc.)
+     */
+    async createApmPaymentInstrument(apmData) {
+        console.log('Creating APM payment instrument:', apmData);
+        const paymentInstrumentData = {
+            type: 'apm',
+            provider: apmData.provider,
+            paymentMethod: apmData.paymentMethod,
+            processorId: apmData.processorId,
+        };
+        const response = await this.apiClient.post('/api/v1/payment/create-payment-instrument', { paymentInstrumentData });
+        console.log('APM payment instrument created:', response);
+        return response;
+    }
     /**
      * Helper function to format expiry date
      */
@@ -124,15 +135,22 @@ export class PaymentsResource {
      */
     async processPaymentDirect(checkoutSessionId, paymentInstrumentId, threedsSessionId, options = {}) {
         console.log('[PaymentsResource] processPaymentDirect START', options.paymentFlowId ? `(flow: ${options.paymentFlowId})` : '');
+        console.log('[PaymentsResource] Full options object:', JSON.stringify(options, null, 2));
+        console.log('[PaymentsResource] processorId:', options.processorId, 'paymentMethod:', options.paymentMethod);
         try {
-            const response = await this.apiClient.post('/api/public/v1/checkout/pay-v2', {
+            const requestBody = {
                 checkoutSessionId,
                 paymentInstrumentId,
                 ...(threedsSessionId && { threedsSessionId }),
                 ...(options.initiatedBy && { initiatedBy: options.initiatedBy }),
                 ...(options.source && { source: options.source }),
                 ...(options.paymentFlowId && { paymentFlowId: options.paymentFlowId }),
-            });
+                ...(options.processorId && { processorId: options.processorId }),
+                ...(options.paymentMethod && { paymentMethod: options.paymentMethod }),
+                ...(options.isExpress && { isExpress: options.isExpress }),
+            };
+            console.log('[PaymentsResource] Request body being sent:', JSON.stringify(requestBody, null, 2));
+            const response = await this.apiClient.post('/api/public/v1/checkout/pay-v2', requestBody);
             console.log('[PaymentsResource] processPaymentDirect SUCCESS:', response);
             return response;
         }

package/dist/v2/core/resources/postPurchases.d.ts

@@ -110,6 +110,7 @@ export interface CheckoutSessionState {
     selectedVariants: Record<string, string>;
     loadingVariants: Record<string, boolean>;
     isUpdatingSummary: boolean;
+    isWhop?: boolean;
 }
 export declare class PostPurchasesResource {
     private apiClient;
@@ -172,6 +173,22 @@ export declare class PostPurchasesResource {
      * Get order summary for a checkout session
      */
     getOrderSummary(sessionId: string, includeVariantOptions?: boolean): Promise<any>;
+    /**
+     * Get payment methods for a checkout session
+     */
+    getPaymentMethods(checkoutSessionId: string): Promise<{
+        type: string;
+    }[]>;
+    /**
+     * Charge a Whop post-purchase using the stored payment method from the original order
+     */
+    chargeWhopPostPurchase(params: {
+        checkoutSessionId: string;
+        orderId: string;
+        storeId: string;
+    }): Promise<{
+        checkoutRequestId: string;
+    }>;
     /**
      * Update line items for a checkout session
      */

package/dist/v2/core/resources/postPurchases.js

@@ -108,6 +108,26 @@ export class PostPurchasesResource {
             includeVariantOptions,
         });
     }
+    /**
+     * Get payment methods for a checkout session
+     */
+    async getPaymentMethods(checkoutSessionId) {
+        return this.apiClient.get(`/api/v1/payment-methods?checkoutSessionId=${encodeURIComponent(checkoutSessionId)}`);
+    }
+    /**
+     * Charge a Whop post-purchase using the stored payment method from the original order
+     */
+    async chargeWhopPostPurchase(params) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${params.checkoutSessionId}/whop-charge-payment`, {
+            checkoutSessionId: params.checkoutSessionId,
+            orderId: params.orderId,
+            storeId: params.storeId,
+            metadata: {
+                comingFromPostPurchase: true,
+                originalOrderId: params.orderId,
+            },
+        });
+    }
     /**
      * Update line items for a checkout session
      */

package/dist/v2/core/types.d.ts

@@ -1,6 +1,9 @@
 /**
  * Types for the Tagada Pay SDK Core
  */
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
 export type Environment = 'production' | 'development' | 'local';
 export interface ApiConfig {
     baseUrl: string;
@@ -86,6 +89,40 @@ export interface PickupPoint {
     opening_hours?: string;
     extra_info?: string;
 }
+export interface Subscription {
+    id: string;
+    status: string;
+    planName?: string;
+    interval?: string;
+    intervalCount?: number;
+    currentPeriodEnd?: string;
+    currentPeriodStart?: string;
+    cancelAtPeriodEnd?: boolean;
+    trialEnd?: string | null;
+    [key: string]: unknown;
+}
+export interface DeviceGeoData {
+    city?: string;
+    regionName?: string;
+    country?: string;
+    [key: string]: unknown;
+}
+export interface DeviceInfo {
+    userAgent?: string;
+    ip?: string;
+    country?: string;
+    browser?: string;
+    browserVersion?: string;
+    os?: string;
+    osVersion?: string;
+    geoData?: DeviceGeoData;
+    [key: string]: unknown;
+}
+export interface PromotionCode {
+    id: string;
+    code: string;
+    [key: string]: unknown;
+}
 export interface OrderItem {
     id: string;
     productId: string;
@@ -141,15 +178,16 @@ export interface Order {
     paidAmount: number;
     status: string;
     createdAt: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     items: OrderItem[];
     summaries?: OrderSummary[];
     shippingAddress?: OrderAddress;
     billingAddress?: OrderAddress;
-    pickupAddress?: PickupPoint;
+    pickupAddress?: PickupPoint | null;
+    customer?: Customer;
     checkoutSession?: {
         returnUrl?: string;
-        [key: string]: any;
+        [key: string]: unknown;
     };
     relatedOrders?: Order[];
 }
@@ -161,7 +199,7 @@ export interface PaymentSummary {
     createdAt: string;
     updatedAt?: string;
     provider?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 export interface PromotionSummary {
     id: string;
@@ -188,10 +226,10 @@ export interface OrderWithRelations extends Order {
     checkoutSession?: {
         id?: string;
         returnUrl?: string;
-        [key: string]: any;
+        [key: string]: unknown;
     };
     promotions?: PromotionSummary[];
-    subscriptions?: any[];
+    subscriptions?: Subscription[];
     adjustments: OrderAdjustmentSummary[];
 }
 export interface CustomerAddress {
@@ -225,7 +263,7 @@ export interface CustomerOrderSummary {
     externalOrderId: string | null;
     billingAddress: CustomerAddress;
     shippingAddress: Omit<CustomerAddress, 'email'>;
-    pickupAddress: any | null;
+    pickupAddress: PickupPoint | null;
     taxesIncluded: boolean;
     draft: boolean;
     checkoutSessionId: string | null;
@@ -235,7 +273,7 @@ export interface CustomerOrderSummary {
     paymentInstrumentId: string | null;
     refundedAt: string | null;
     refundedAmount: number | null;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 export interface CustomerInfos {
     customer: {
@@ -255,12 +293,12 @@ export interface CustomerInfos {
         acceptsMarketing: boolean;
         createdAt: string;
         updatedAt: string;
-        metadata: Record<string, any>;
-        device: any | null;
+        metadata: Record<string, unknown>;
+        device: DeviceInfo | null;
         orders: CustomerOrderSummary[];
-        subscriptions: any[];
+        subscriptions: Subscription[];
     };
-    promotionCodes: any[];
+    promotionCodes: PromotionCode[];
 }
 export interface SessionInitResponse {
     store: Store;

package/dist/v2/core/types.js

@@ -1,4 +1 @@
-/**
- * Types for the Tagada Pay SDK Core
- */
 export {};

package/dist/v2/core/utils/checkout.d.ts

@@ -2,8 +2,8 @@
  * Checkout Utility Functions
  * Pure functions for checkout data manipulation
  */
-import type { CheckoutData, CheckoutSession, CheckoutLineItem, CheckoutInitParams, Promotion } from '../resources/checkout';
-export type { CheckoutData, CheckoutSession, CheckoutLineItem, CheckoutInitParams, Promotion, };
+import type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, Promotion } from '../resources/checkout';
+export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, Promotion };
 export declare class CheckoutUtils {
     /**
      * Get checkout session ID

package/dist/v2/core/utils/checkout.js

@@ -13,13 +13,18 @@ export class CheckoutUtils {
      * Get checkout line items
      */
     static getLineItems(checkoutData) {
-        return checkoutData.checkoutSession?.lineItems || [];
+        const lineItems = checkoutData.checkoutSession?.lineItems;
+        if (!Array.isArray(lineItems)) {
+            return [];
+        }
+        return lineItems;
     }
     /**
      * Get checkout total
      */
     static getTotal(checkoutData) {
-        return checkoutData.checkoutSession?.totalPrice || 0;
+        const totalPrice = checkoutData.checkoutSession?.totalPrice;
+        return typeof totalPrice === 'number' ? totalPrice : 0;
     }
     /**
      * Check if customer is club member

package/dist/v2/core/utils/currency.d.ts

@@ -8,6 +8,20 @@ export interface Currency {
     name: string;
     decimalPlaces: number;
 }
+/**
+ * Format money amount from minor units (cents) to a formatted string
+ *
+ * @param amountMinorUnits - Amount in minor units (e.g., 12345 for $123.45)
+ * @param currencyCode - ISO 4217 currency code (e.g., "USD", "EUR")
+ * @param locale - Locale for formatting (default: "en-US")
+ * @returns Formatted money string (e.g., "$123.45")
+ *
+ * @example
+ * formatMoney(12345, 'USD') // "$123.45"
+ * formatMoney(10000, 'EUR', 'de-DE') // "100,00 €"
+ * formatMoney(1000, 'JPY') // "¥1,000"
+ */
+export declare function formatMoney(amountMinorUnits: number, currencyCode?: string, locale?: string): string;
 export declare class CurrencyUtils {
     /**
      * Get currency from context or fallback to default

package/dist/v2/core/utils/currency.js

@@ -2,6 +2,46 @@
  * Currency Utility Functions
  * Pure functions for currency management
  */
+/**
+ * Format money amount from minor units (cents) to a formatted string
+ *
+ * @param amountMinorUnits - Amount in minor units (e.g., 12345 for $123.45)
+ * @param currencyCode - ISO 4217 currency code (e.g., "USD", "EUR")
+ * @param locale - Locale for formatting (default: "en-US")
+ * @returns Formatted money string (e.g., "$123.45")
+ *
+ * @example
+ * formatMoney(12345, 'USD') // "$123.45"
+ * formatMoney(10000, 'EUR', 'de-DE') // "100,00 €"
+ * formatMoney(1000, 'JPY') // "¥1,000"
+ */
+export function formatMoney(amountMinorUnits, currencyCode = 'USD', locale = 'en-US') {
+    const decimalPlaces = CurrencyUtils.getDecimalPlaces(currencyCode);
+    // Convert minor units to major units
+    // Backend stores amounts with 2 decimal places for all currencies
+    // For currencies with 0 decimal places (JPY, KRW, etc.), divide by 100
+    let value;
+    if (decimalPlaces === 0) {
+        // For zero-decimal currencies, backend still stores with 2 decimals
+        value = amountMinorUnits / 100;
+    }
+    else {
+        value = amountMinorUnits / Math.pow(10, decimalPlaces);
+    }
+    try {
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: currencyCode,
+            minimumFractionDigits: decimalPlaces,
+            maximumFractionDigits: decimalPlaces,
+        }).format(value);
+    }
+    catch {
+        // Fallback if Intl.NumberFormat fails
+        const symbol = CurrencyUtils.getCurrencySymbol(currencyCode);
+        return `${symbol}${value.toFixed(decimalPlaces)}`;
+    }
+}
 export class CurrencyUtils {
     /**
      * Get currency from context or fallback to default

package/dist/v2/core/utils/deviceInfo.d.ts

@@ -5,7 +5,6 @@ export interface DeviceInfo {
             major: string;
             name: string;
             version: string;
-            type?: string;
         };
         os: {
             name: string;
@@ -36,17 +35,8 @@ export interface DeviceInfo {
         isAppleSilicon: boolean;
     };
 }
-/**
- * Get browser locale
- */
 export declare function getBrowserLocale(): string;
-/**
- * Collect all device information using UAParser
- */
 export declare function collectDeviceInfo(): DeviceInfo;
-/**
- * Get URL parameters for session initialization
- */
 export declare function getUrlParams(): {
     locale?: string;
     currency?: string;