@tagadapay/plugin-sdk 2.6.18 → 2.7.0

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

@@ -0,0 +1,150 @@
+/**
+ * Customer Resource Client
+ * Handles customer-related API operations
+ */
+import { ApiClient } from './apiClient';
+export interface CustomerAddress {
+    firstName: string | null;
+    lastName: string | null;
+    address1: string | null;
+    address2: string | null;
+    city: string | null;
+    province: string | null;
+    country: string | null;
+    zip: string | null;
+    phone: string | null;
+    email?: string | null;
+}
+export interface CustomerOrderSummary {
+    id: string;
+    totalPrice: number;
+    currency: string;
+    createdAt: string;
+    status: string;
+}
+export interface CustomerInfos {
+    customer: {
+        id: string;
+        email: string | null;
+        firstName: string | null;
+        lastName: string | null;
+        externalCustomerId: string | null;
+        lastOrderId: string | null;
+        accountId: string;
+        storeId: string;
+        billingAddress: CustomerAddress | null;
+        shippingAddress: Omit<CustomerAddress, 'email'> | null;
+        currency: string | null;
+        locale: string | null;
+        draft: boolean;
+        acceptsMarketing: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, any>;
+        device: any | null;
+        orders: CustomerOrderSummary[];
+        subscriptions: any[];
+    };
+    promotionCodes: any[];
+}
+export interface OrderWithRelations {
+    id: string;
+    currency: string;
+    paidAmount: number;
+    status: string;
+    createdAt: string;
+    metadata?: Record<string, any>;
+    items: any[];
+    summaries?: any[];
+    shippingAddress?: any;
+    billingAddress?: any;
+    pickupAddress?: any;
+    checkoutSession?: {
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    relatedOrders?: any[];
+    customer?: any;
+    store?: any;
+    account?: {
+        id: string;
+        name?: string;
+    };
+    payments?: any[];
+    promotions?: any[];
+    subscriptions?: any[];
+    adjustments: any[];
+}
+export interface Subscription {
+    id: string;
+    status: string;
+    createdAt: string;
+    currency: string;
+    cancelAtPeriodEnd: boolean;
+    currentPeriodEnd: string | null;
+    currentPeriodStart: string | null;
+    quantity: number;
+    trialEnd: string | null;
+    customerId: string;
+    customerEmail: string;
+    customerName: string;
+    priceCurrencyOptions: Record<string, {
+        rate: number;
+        amount: number;
+        lock: boolean;
+        date: string;
+    }>;
+    priceInterval: string;
+    priceIntervalCount: number;
+    priceRecurring: boolean;
+    productId: string;
+    priceId: string;
+    productTitle: string;
+}
+export interface SubscriptionsResponse {
+    items: Subscription[];
+    pagination: {
+        page: number;
+        pageSize: number;
+        hasNext: boolean;
+        nextPage: number | null;
+        previousPage: number | null;
+        totalItems: number;
+    };
+}
+export declare class CustomerResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Get customer information by ID
+     */
+    getCustomerInfos(customerId: string, storeId: string): Promise<CustomerInfos>;
+    /**
+     * Update customer information
+     */
+    updateCustomer(customerId: string, data: {
+        email?: string;
+        firstName?: string;
+        lastName?: string;
+        acceptsMarketing?: boolean;
+        metadata?: Record<string, any>;
+    }): Promise<CustomerInfos>;
+    /**
+     * Get customer orders
+     */
+    getCustomerOrders(customerId: string, storeId: string): Promise<{
+        orders: OrderWithRelations[];
+    }>;
+    /**
+     * Get customer subscriptions
+     */
+    getCustomerSubscriptions(): Promise<SubscriptionsResponse>;
+    /**
+     * Resume a subscription
+     */
+    resumeSubscription(subscriptionId: string): Promise<void>;
+    /**
+     * Cancel a subscription
+     */
+    cancelSubscription(subscriptionId: string): Promise<void>;
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Customer Resource Client
+ * Handles customer-related API operations
+ */
+export class CustomerResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Get customer information by ID
+     */
+    async getCustomerInfos(customerId, storeId) {
+        return this.apiClient.get(`/api/v1/customers/${customerId}`, {
+            params: { storeId },
+        });
+    }
+    /**
+     * Update customer information
+     */
+    async updateCustomer(customerId, data) {
+        return this.apiClient.patch(`/api/v1/customers/${customerId}`, data);
+    }
+    /**
+     * Get customer orders
+     */
+    async getCustomerOrders(customerId, storeId) {
+        return this.apiClient.get(`/api/v1/orders/customer/${customerId}`, {
+            params: { storeId },
+        });
+    }
+    /**
+     * Get customer subscriptions
+     */
+    async getCustomerSubscriptions() {
+        return this.apiClient.get('/api/v1/subscriptions');
+    }
+    /**
+     * Resume a subscription
+     */
+    async resumeSubscription(subscriptionId) {
+        return this.apiClient.post('/api/v1/subscriptions/resume', {
+            subscriptionId,
+        });
+    }
+    /**
+     * Cancel a subscription
+     */
+    async cancelSubscription(subscriptionId) {
+        return this.apiClient.post('/api/v1/subscriptions/cancel', {
+            subscriptionId,
+        });
+    }
+}

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

@@ -4,15 +4,17 @@
  */
 export * from './apiClient';
 export * from './checkout';
+export * from './customer';
 export * from './discounts';
+export * from './funnel';
 export * from './offers';
 export * from './orders';
 export * from './payments';
 export * from './postPurchases';
 export * from './products';
 export * from './promotions';
+export * from './session';
 export * from './shippingRates';
 export * from './storeConfig';
 export * from './threeds';
 export * from './vipOffers';
-export * from './funnel';

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

@@ -4,15 +4,17 @@
  */
 export * from './apiClient';
 export * from './checkout';
+export * from './customer';
 export * from './discounts';
+export * from './funnel';
 export * from './offers';
 export * from './orders';
 export * from './payments';
 export * from './postPurchases';
 export * from './products';
 export * from './promotions';
+export * from './session';
 export * from './shippingRates';
 export * from './storeConfig';
 export * from './threeds';
 export * from './vipOffers';
-export * from './funnel';

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

@@ -0,0 +1,27 @@
+/**
+ * Session Resource Client
+ * Handles authentication and session management
+ */
+import { ApiClient } from './apiClient';
+export interface RequestCodeResponse {
+    success: boolean;
+    error?: string;
+}
+export interface VerifyCodeResponse {
+    success: boolean;
+    token?: string;
+    sessionId?: string;
+    error?: string;
+}
+export declare class SessionResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Request verification code for email
+     */
+    requestCode(email: string, storeId: string): Promise<RequestCodeResponse>;
+    /**
+     * Verify code and login
+     */
+    verifyCode(email: string, code: string, storeId: string): Promise<VerifyCodeResponse>;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Session Resource Client
+ * Handles authentication and session management
+ */
+export class SessionResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Request verification code for email
+     */
+    async requestCode(email, storeId) {
+        try {
+            await this.apiClient.post('/api/v1/cms/session/request-code', {
+                email,
+                storeId,
+            });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to send code',
+            };
+        }
+    }
+    /**
+     * Verify code and login
+     */
+    async verifyCode(email, code, storeId) {
+        try {
+            const response = await this.apiClient.post('/api/v1/cms/session/login', {
+                email,
+                code,
+                storeId,
+            });
+            if (!response) {
+                return {
+                    success: false,
+                    error: 'Invalid code',
+                };
+            }
+            return {
+                success: true,
+                token: response.token,
+                sessionId: response.sessionId,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to verify code',
+            };
+        }
+    }
+}

package/dist/v2/index.d.ts

@@ -20,5 +20,13 @@ export type { ShippingRate, ShippingRatesResponse } from './core/resources/shipp
 export type { ApplyDiscountResponse, Discount, DiscountCodeValidation, RemoveDiscountResponse } from './core/resources/discounts';
 export type { ToggleOrderBumpResponse, VipOffer, VipPreviewResponse } from './core/resources/vipOffers';
 export type { StoreConfig } from './core/resources/storeConfig';
-export type { FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext, FunnelInitializeRequest, FunnelInitializeResponse, FunnelNavigateRequest, FunnelNavigateResponse, FunnelContextUpdateRequest, FunnelContextUpdateResponse } from './core/resources/funnel';
-export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers, useFunnel, useSimpleFunnel } from './react';
+export type { FunnelContextUpdateRequest, FunnelContextUpdateResponse, FunnelEvent, FunnelInitializeRequest, FunnelInitializeResponse, FunnelNavigateRequest, FunnelNavigateResponse, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext } from './core/resources/funnel';
+export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useAuth, useCheckout, useCheckoutToken, useClubOffers, useCountryOptions, useCurrency, useCustomer, useCustomerInfos, useCustomerOrders, useCustomerSubscriptions, useDiscounts, useExpressPaymentMethods, useFunnel, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useLogin, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useSimpleFunnel, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useTranslation, useVipOffers } from './react';
+export type { TranslateFunction, UseTranslationOptions, UseTranslationResult } from './react/hooks/useTranslation';
+export type { ClubOffer, ClubOfferItem, ClubOfferLineItem, ClubOfferSummary, UseClubOffersOptions, UseClubOffersResult } from './react/hooks/useClubOffers';
+export type { UseLoginOptions, UseLoginResult } from './react/hooks/useLogin';
+export type { CustomerAddress, CustomerInfos, CustomerOrderSummary, OrderWithRelations, Subscription, SubscriptionsResponse } from './core/resources/customer';
+export type { UseCustomerResult } from './react/hooks/useCustomer';
+export type { UseCustomerInfosOptions, UseCustomerInfosResult } from './react/hooks/useCustomerInfos';
+export type { UseCustomerOrdersOptions, UseCustomerOrdersResult } from './react/hooks/useCustomerOrders';
+export type { UseCustomerSubscriptionsOptions, UseCustomerSubscriptionsResult } from './react/hooks/useCustomerSubscriptions';

package/dist/v2/index.js

@@ -12,4 +12,4 @@ export * from './core/utils/currency';
 export * from './core/utils/pluginConfig';
 export * from './core/utils/products';
 // React exports (hooks and components only, types are exported above)
-export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers, useFunnel, useSimpleFunnel } from './react';
+export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useAuth, useCheckout, useCheckoutToken, useClubOffers, useCountryOptions, useCurrency, useCustomer, useCustomerInfos, useCustomerOrders, useCustomerSubscriptions, useDiscounts, useExpressPaymentMethods, useFunnel, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useLogin, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useSimpleFunnel, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useTranslation, useVipOffers } from './react';

package/dist/v2/react/hooks/useAuth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * useAuth - Hook to access authentication state (v2)
+ * Uses TagadaContext for auth state management
+ */
+import { AuthState } from '../../../react/types';
+export declare function useAuth(): AuthState & {
+    isInitialized: boolean;
+};

package/dist/v2/react/hooks/useAuth.js

@@ -0,0 +1,9 @@
+'use client';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useAuth() {
+    const { auth, isInitialized } = useTagadaContext();
+    return {
+        ...auth,
+        isInitialized,
+    };
+}

package/dist/v2/react/hooks/useClubOffers.d.ts

@@ -0,0 +1,101 @@
+export interface ClubOfferItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    product: {
+        name: string;
+        description: string;
+    };
+    variant: {
+        name: string;
+        description: string;
+        imageUrl: string;
+        grams: number;
+    };
+    unitAmount: number;
+    quantity: number;
+    amount: number;
+    adjustedAmount: number;
+}
+export interface ClubOfferSummary {
+    currency: string;
+    totalAmount: number;
+    totalAdjustedAmount: number;
+    items: ClubOfferItem[];
+}
+export interface ClubOfferLineItem {
+    id: string;
+    quantity: number;
+    price: {
+        variant: {
+            id: string;
+            name: string;
+            description: string | null;
+            imageUrl: string;
+            grams: number;
+            product: {
+                id: string;
+                name: string;
+                description: string;
+            };
+        };
+    };
+}
+export interface ClubOffer {
+    id: string;
+    titleTrans: {
+        en: string;
+    };
+    summaries: ClubOfferSummary[];
+    offerLineItems: ClubOfferLineItem[];
+}
+export interface UseClubOffersOptions {
+    /**
+     * Whether to fetch club offers automatically on mount
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Return URL for payment
+     */
+    returnUrl?: string;
+}
+export interface UseClubOffersResult {
+    /**
+     * Array of fetched club offers
+     */
+    offers: ClubOffer[];
+    /**
+     * Loading state
+     */
+    isLoading: boolean;
+    /**
+     * Error state
+     */
+    error: Error | null;
+    /**
+     * Refetch club offers
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Get club offer by ID from the loaded offers
+     */
+    getOffer: (offerId: string) => ClubOffer | undefined;
+    /**
+     * Get total value of all club offers
+     */
+    getTotalValue: () => number;
+    /**
+     * Get total savings across all club offers
+     */
+    getTotalSavings: () => number;
+    /**
+     * Clear error state
+     */
+    clearError: () => void;
+    /**
+     * Pay for a club offer
+     */
+    payOffer: (offerId: string, returnUrl?: string) => Promise<void>;
+}
+export declare function useClubOffers(options?: UseClubOffersOptions): UseClubOffersResult;

package/dist/v2/react/hooks/useClubOffers.js

@@ -0,0 +1,126 @@
+'use client';
+/**
+ * useClubOffers - Hook for club-specific offers (v2)
+ * Extends the offers functionality with club filtering
+ */
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { OffersResource } from '../../core/resources/offers';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+/**
+ * Transform generic Offer to ClubOffer format
+ */
+function transformToClubOffer(offer) {
+    return {
+        id: offer.id,
+        titleTrans: offer.titleTrans,
+        summaries: offer.summaries.map((summary) => ({
+            currency: summary.currency,
+            totalAmount: summary.totalAmount,
+            totalAdjustedAmount: summary.totalAdjustedAmount,
+            items: summary.items.map((item) => ({
+                id: item.id,
+                productId: item.id, // Using item ID as productId fallback
+                variantId: item.id, // Using item ID as variantId fallback
+                product: item.product,
+                variant: {
+                    name: item.variant.name,
+                    description: '', // Not available in base Offer
+                    imageUrl: item.variant.imageUrl,
+                    grams: 0, // Not available in base Offer
+                },
+                unitAmount: item.unitAmount,
+                quantity: item.quantity,
+                amount: item.amount,
+                adjustedAmount: item.adjustedAmount,
+            })),
+        })),
+        offerLineItems: [], // Not available in base Offer
+    };
+}
+export function useClubOffers(options = {}) {
+    const { enabled = true, returnUrl } = options;
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    // Create offers resource client
+    const offersResource = useMemo(() => {
+        try {
+            return new OffersResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize offers resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Create query key
+    const queryKey = useMemo(() => ['club-offers', { storeId }], [storeId]);
+    // Fetch club offers using TanStack Query
+    const { data: offers = [], isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: enabled && !!storeId && isSessionInitialized,
+        queryFn: async () => {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            // Fetch all offers and filter for club type
+            // Note: The API endpoint should support a 'type' parameter
+            const response = await getGlobalApiClient().get(`/api/v1/stores/${storeId}/offers`, {
+                params: {
+                    type: 'club',
+                },
+            });
+            // Transform to club offer format
+            return (response.offers || []).map(transformToClubOffer);
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    // Pay offer mutation
+    const payOfferMutation = useMutation({
+        mutationFn: async ({ offerId, returnUrl }) => {
+            const url = returnUrl || (typeof window !== 'undefined' ? window.location.href : '');
+            return await offersResource.payOffer(offerId);
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to pay offer:', error);
+        },
+    });
+    // Helper functions
+    const getOffer = useCallback((offerId) => {
+        return offers.find((offer) => offer.id === offerId);
+    }, [offers]);
+    const getTotalValue = useCallback(() => {
+        return offers.reduce((total, offer) => {
+            const firstSummary = offer.summaries[0];
+            return total + (firstSummary?.totalAdjustedAmount || 0);
+        }, 0);
+    }, [offers]);
+    const getTotalSavings = useCallback(() => {
+        return offers.reduce((total, offer) => {
+            const firstSummary = offer.summaries[0];
+            return total + (firstSummary?.totalAmount - firstSummary?.totalAdjustedAmount || 0);
+        }, 0);
+    }, [offers]);
+    const clearError = useCallback(() => {
+        // TanStack Query doesn't have a direct clearError method
+        // Error will be cleared on next successful fetch
+    }, []);
+    const payOffer = useCallback(async (offerId, returnUrl) => {
+        await payOfferMutation.mutateAsync({ offerId, returnUrl });
+    }, [payOfferMutation]);
+    return {
+        offers,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+        getOffer,
+        getTotalValue,
+        getTotalSavings,
+        clearError,
+        payOffer,
+    };
+}

package/dist/v2/react/hooks/useCustomer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * useCustomer - Hook to access current customer data (v2)
+ */
+import { Customer } from '../../../react/types';
+export interface UseCustomerResult {
+    customer: Customer | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    isAnonymous: boolean;
+}
+export declare function useCustomer(): UseCustomerResult;

package/dist/v2/react/hooks/useCustomer.js

@@ -0,0 +1,11 @@
+'use client';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useCustomer() {
+    const { customer, isLoading } = useTagadaContext();
+    return {
+        customer,
+        isAuthenticated: customer?.isAuthenticated || false,
+        isLoading,
+        isAnonymous: customer?.role === 'anonymous',
+    };
+}

package/dist/v2/react/hooks/useCustomerInfos.d.ts

@@ -0,0 +1,12 @@
+import { CustomerInfos } from '../../core/resources/customer';
+export interface UseCustomerInfosOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerInfosResult {
+    data: CustomerInfos | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+export declare function useCustomerInfos(options?: UseCustomerInfosOptions): UseCustomerInfosResult;

package/dist/v2/react/hooks/useCustomerInfos.js

@@ -0,0 +1,53 @@
+'use client';
+/**
+ * useCustomerInfos - Hook to fetch customer information (v2)
+ * Fetches customer infos from `/api/v1/customers/{customerId}` with `storeId` param
+ */
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useCustomerInfos(options = {}) {
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && storeId && isSessionInitialized);
+    }, [enabled, customerId, storeId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-infos', { customerId, storeId }], [customerId, storeId]);
+    // Fetch customer infos using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId || !storeId) {
+                return null;
+            }
+            return await customerResource.getCustomerInfos(customerId, storeId);
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+    };
+}

package/dist/v2/react/hooks/useCustomerOrders.d.ts

@@ -0,0 +1,17 @@
+/**
+ * useCustomerOrders - Hook to fetch customer orders (v2)
+ */
+import { OrderWithRelations } from '../../core/resources/customer';
+export interface UseCustomerOrdersOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerOrdersResult {
+    data: {
+        orders: OrderWithRelations[];
+    } | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+export declare function useCustomerOrders(options?: UseCustomerOrdersOptions): UseCustomerOrdersResult;

package/dist/v2/react/hooks/useCustomerOrders.js

@@ -0,0 +1,51 @@
+/**
+ * useCustomerOrders - Hook to fetch customer orders (v2)
+ */
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useCustomerOrders(options = {}) {
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && storeId && isSessionInitialized);
+    }, [enabled, customerId, storeId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-orders', { customerId, storeId }], [customerId, storeId]);
+    // Fetch customer orders using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId || !storeId) {
+                return null;
+            }
+            return await customerResource.getCustomerOrders(customerId, storeId);
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+    };
+}

package/dist/v2/react/hooks/useCustomerSubscriptions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * useCustomerSubscriptions - Hook to manage customer subscriptions (v2)
+ */
+import { SubscriptionsResponse } from '../../core/resources/customer';
+export interface UseCustomerSubscriptionsOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerSubscriptionsResult {
+    data: SubscriptionsResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    resumeSubscription: (subscriptionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    cancelSubscription: (subscriptionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+export declare function useCustomerSubscriptions(options?: UseCustomerSubscriptionsOptions): UseCustomerSubscriptionsResult;

package/dist/v2/react/hooks/useCustomerSubscriptions.js

@@ -0,0 +1,94 @@
+/**
+ * useCustomerSubscriptions - Hook to manage customer subscriptions (v2)
+ */
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+export function useCustomerSubscriptions(options = {}) {
+    const { isSessionInitialized } = useTagadaContext();
+    const queryClient = useQueryClient();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && isSessionInitialized);
+    }, [enabled, customerId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-subscriptions', { customerId }], [customerId]);
+    // Fetch customer subscriptions using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId) {
+                return null;
+            }
+            return await customerResource.getCustomerSubscriptions();
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    // Resume subscription mutation
+    const resumeMutation = useMutation({
+        mutationFn: async (subscriptionId) => {
+            return await customerResource.resumeSubscription(subscriptionId);
+        },
+        onSuccess: () => {
+            // Invalidate and refetch subscriptions
+            void queryClient.invalidateQueries({ queryKey });
+        },
+    });
+    // Cancel subscription mutation
+    const cancelMutation = useMutation({
+        mutationFn: async (subscriptionId) => {
+            return await customerResource.cancelSubscription(subscriptionId);
+        },
+        onSuccess: () => {
+            // Invalidate and refetch subscriptions
+            void queryClient.invalidateQueries({ queryKey });
+        },
+    });
+    // Resume subscription
+    const resumeSubscription = useCallback(async (subscriptionId) => {
+        try {
+            await resumeMutation.mutateAsync(subscriptionId);
+            return { success: true };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to resume subscription';
+            return { success: false, error: errorMessage };
+        }
+    }, [resumeMutation]);
+    // Cancel subscription
+    const cancelSubscription = useCallback(async (subscriptionId) => {
+        try {
+            await cancelMutation.mutateAsync(subscriptionId);
+            return { success: true };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to cancel subscription';
+            return { success: false, error: errorMessage };
+        }
+    }, [cancelMutation]);
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+        resumeSubscription,
+        cancelSubscription,
+    };
+}

package/dist/v2/react/hooks/useLogin.d.ts

@@ -0,0 +1,53 @@
+export interface UseLoginOptions {
+    /**
+     * Callback when login is successful
+     */
+    onSuccess?: (token: string) => void;
+    /**
+     * Callback when an error occurs
+     */
+    onError?: (error: Error) => void;
+}
+export interface UseLoginResult {
+    /**
+     * Request verification code for email
+     */
+    requestCode: (email: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Verify code and complete login
+     */
+    verifyCode: (email: string, code: string) => Promise<{
+        success: boolean;
+        token?: string;
+        sessionId?: string;
+        error?: string;
+    }>;
+    /**
+     * Combined loading state (true if either request or verify is loading)
+     */
+    isLoading: boolean;
+    /**
+     * Loading state for request code
+     */
+    isRequestingCode: boolean;
+    /**
+     * Loading state for verify code
+     */
+    isVerifyingCode: boolean;
+    /**
+     * Combined error state
+     */
+    error: Error | null;
+    /**
+     * Error from request code
+     */
+    requestCodeError: Error | null;
+    /**
+     * Error from verify code
+     */
+    verifyCodeError: Error | null;
+}
+export declare function useLogin(options?: UseLoginOptions): UseLoginResult;

package/dist/v2/react/hooks/useLogin.js

@@ -0,0 +1,75 @@
+'use client';
+/**
+ * useLogin - Hook for authentication (v2)
+ * Handles email/code authentication flow
+ */
+import { useMutation } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { setClientToken } from '../../../react/utils/tokenStorage';
+import { SessionResource } from '../../core/resources/session';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useLogin(options = {}) {
+    const { onSuccess, onError } = options;
+    const { storeId } = usePluginConfig();
+    // Create session resource client
+    const sessionResource = useMemo(() => {
+        try {
+            return new SessionResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize session resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Request code mutation
+    const requestCodeMutation = useMutation({
+        mutationFn: async (email) => {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            return await sessionResource.requestCode(email, storeId);
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to request code:', error);
+            onError?.(error);
+        },
+    });
+    // Verify code mutation
+    const verifyCodeMutation = useMutation({
+        mutationFn: async ({ email, code }) => {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            const result = await sessionResource.verifyCode(email, code, storeId);
+            if (result.success && result.token) {
+                // Store the token
+                setClientToken(result.token);
+                // Call success callback
+                onSuccess?.(result.token);
+            }
+            return result;
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to verify code:', error);
+            onError?.(error);
+        },
+    });
+    // Action functions
+    const requestCode = useCallback(async (email) => {
+        return await requestCodeMutation.mutateAsync(email);
+    }, [requestCodeMutation]);
+    const verifyCode = useCallback(async (email, code) => {
+        return await verifyCodeMutation.mutateAsync({ email, code });
+    }, [verifyCodeMutation]);
+    return {
+        requestCode,
+        verifyCode,
+        isLoading: requestCodeMutation.isPending || verifyCodeMutation.isPending,
+        isRequestingCode: requestCodeMutation.isPending,
+        isVerifyingCode: verifyCodeMutation.isPending,
+        error: requestCodeMutation.error || verifyCodeMutation.error,
+        requestCodeError: requestCodeMutation.error,
+        verifyCodeError: verifyCodeMutation.error,
+    };
+}

package/dist/v2/react/hooks/useTranslation.js

@@ -29,7 +29,7 @@ export const useTranslation = (options = {}) => {
         // Check for language query parameter
         if (typeof window !== 'undefined') {
             const urlParams = new URLSearchParams(window.location.search);
-            const langFromQuery = urlParams.get('language');
+            const langFromQuery = urlParams.get('locale');
             if (langFromQuery)
                 return langFromQuery;
         }

package/dist/v2/react/index.d.ts

@@ -6,11 +6,18 @@ export { ExpressPaymentMethodsProvider } from './providers/ExpressPaymentMethods
 export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
 export { ApplePayButton } from './components/ApplePayButton';
 export { GooglePayButton } from './components/GooglePayButton';
+export { useAuth } from './hooks/useAuth';
 export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { useClubOffers } from './hooks/useClubOffers';
+export { useCustomer } from './hooks/useCustomer';
+export { useCustomerInfos } from './hooks/useCustomerInfos';
+export { useCustomerOrders } from './hooks/useCustomerOrders';
+export { useCustomerSubscriptions } from './hooks/useCustomerSubscriptions';
 export { useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 export { useGeoLocation } from './hooks/useGeoLocation';
 export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
 export { getAvailableLanguages, useCountryOptions, useISOData, useLanguageImport, useRegionOptions } from './hooks/useISOData';
+export { useLogin } from './hooks/useLogin';
 export { usePluginConfig } from './hooks/usePluginConfig';
 export { queryKeys, useApiMutation, useApiQuery, useInvalidateQuery, usePreloadQuery } from './hooks/useApiQuery';
 export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
@@ -27,18 +34,27 @@ export { useShippingRatesQuery as useShippingRates } from './hooks/useShippingRa
 export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQuery';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
+export { useTranslation } from './hooks/useTranslation';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
 export { useFunnel, useSimpleFunnel } from './hooks/useFunnel';
 export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
+export type { ClubOffer, ClubOfferItem, ClubOfferLineItem, ClubOfferSummary, UseClubOffersOptions, UseClubOffersResult } from './hooks/useClubOffers';
+export type { UseCustomerResult } from './hooks/useCustomer';
+export type { UseCustomerInfosOptions, UseCustomerInfosResult } from './hooks/useCustomerInfos';
+export type { UseCustomerOrdersOptions, UseCustomerOrdersResult } from './hooks/useCustomerOrders';
+export type { UseCustomerSubscriptionsOptions, UseCustomerSubscriptionsResult } from './hooks/useCustomerSubscriptions';
 export type { ExpressPaymentMethodsContextType, ExpressPaymentMethodsProviderProps } from './hooks/useExpressPaymentMethods';
+export type { UseLoginOptions, UseLoginResult } from './hooks/useLogin';
 export type { ApplePayButtonProps } from './components/ApplePayButton';
 export type { GooglePayButtonProps } from './components/GooglePayButton';
 export type { GeoLocationData, UseGeoLocationOptions, UseGeoLocationReturn } from './hooks/useGeoLocation';
 export type { ExtractedAddress, GooglePlaceDetails, GooglePrediction, UseGoogleAutocompleteOptions, UseGoogleAutocompleteResult } from './hooks/useGoogleAutocomplete';
 export type { ISOCountry, ISORegion, UseISODataResult } from './hooks/useISOData';
 export type { UsePluginConfigOptions, UsePluginConfigResult } from './hooks/usePluginConfig';
+export type { TranslateFunction, UseTranslationOptions, UseTranslationResult } from './hooks/useTranslation';
 export type { UseCheckoutQueryOptions as UseCheckoutOptions, UseCheckoutQueryResult as UseCheckoutResult } from './hooks/useCheckoutQuery';
 export type { UseDiscountsQueryOptions as UseDiscountsOptions, UseDiscountsQueryResult as UseDiscountsResult } from './hooks/useDiscountsQuery';
+export type { FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext, UseFunnelOptions, UseFunnelResult } from './hooks/useFunnel';
 export type { UseOffersQueryOptions as UseOffersOptions, UseOffersQueryResult as UseOffersResult } from './hooks/useOffersQuery';
 export type { UseOrderBumpQueryOptions as UseOrderBumpOptions, UseOrderBumpQueryResult as UseOrderBumpResult } from './hooks/useOrderBumpQuery';
 export type { UseOrderQueryOptions as UseOrderOptions, UseOrderQueryResult as UseOrderResult } from './hooks/useOrderQuery';
@@ -50,6 +66,5 @@ export type { UseShippingRatesQueryOptions as UseShippingRatesOptions, UseShippi
 export type { UseStoreConfigQueryOptions as UseStoreConfigOptions, UseStoreConfigQueryResult as UseStoreConfigResult } from './hooks/useStoreConfigQuery';
 export type { PaymentInstrument, ThreedsChallenge, ThreedsHook, ThreedsOptions, ThreedsProvider, ThreedsSession } from './hooks/useThreeds';
 export type { UseVipOffersQueryOptions as UseVipOffersOptions, UseVipOffersQueryResult as UseVipOffersResult } from './hooks/useVipOffersQuery';
-export type { UseFunnelOptions, UseFunnelResult, FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext } from './hooks/useFunnel';
 export { formatMoney } from '../../react/utils/money';
 export type OrderItem = import('../core/utils/order').OrderLineItem;

package/dist/v2/react/index.js

@@ -9,11 +9,18 @@ export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
 export { ApplePayButton } from './components/ApplePayButton';
 export { GooglePayButton } from './components/GooglePayButton';
 // Hooks
+export { useAuth } from './hooks/useAuth';
 export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { useClubOffers } from './hooks/useClubOffers';
+export { useCustomer } from './hooks/useCustomer';
+export { useCustomerInfos } from './hooks/useCustomerInfos';
+export { useCustomerOrders } from './hooks/useCustomerOrders';
+export { useCustomerSubscriptions } from './hooks/useCustomerSubscriptions';
 export { useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 export { useGeoLocation } from './hooks/useGeoLocation';
 export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
 export { getAvailableLanguages, useCountryOptions, useISOData, useLanguageImport, useRegionOptions } from './hooks/useISOData';
+export { useLogin } from './hooks/useLogin';
 export { usePluginConfig } from './hooks/usePluginConfig';
 // TanStack Query hooks (recommended)
 export { queryKeys, useApiMutation, useApiQuery, useInvalidateQuery, usePreloadQuery } from './hooks/useApiQuery';
@@ -31,6 +38,7 @@ export { useShippingRatesQuery as useShippingRates } from './hooks/useShippingRa
 export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQuery';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
+export { useTranslation } from './hooks/useTranslation';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
 // Funnel hooks
 export { useFunnel, useSimpleFunnel } from './hooks/useFunnel';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagadapay/plugin-sdk",
-  "version": "2.6.18",
+  "version": "2.7.0",
   "description": "Modern React SDK for building Tagada Pay plugins",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/v2/react/hooks/useDiscountQuery.d.ts

@@ -1,79 +0,0 @@
-/**
- * Single Discount Hook using TanStack Query
- * Fetches a specific discount for a given store
- */
-import { UseQueryResult } from '@tanstack/react-query';
-export interface StoreDiscountRuleAmount {
-    rate: number;
-    amount: number;
-    lock: boolean;
-    date: string;
-}
-export interface StoreDiscountRule {
-    id: string;
-    createdAt: string;
-    updatedAt: string;
-    promotionId: string;
-    type: string;
-    productId: string | null;
-    minimumQuantity: number | null;
-    minimumAmount: Record<string, StoreDiscountRuleAmount> | null;
-    variantIds: string[] | null;
-}
-export interface StoreDiscountAction {
-    id: string;
-    createdAt: string;
-    updatedAt: string;
-    promotionId: string;
-    type: string;
-    adjustmentAmount: number | null;
-    adjustmentPercentage: number | null;
-    adjustmentType: string | null;
-    freeShipping: boolean | null;
-    priceIdToAdd: string | null;
-    productIdToAdd: string | null;
-    variantIdToAdd: string | null;
-    subscriptionFreeTrialDuration: number | null;
-    subscriptionFreeTrialDurationType: string | null;
-    targetProductId: string | null;
-    targetVariantIds: string[] | null;
-    maxQuantityDiscounted: number | null;
-    appliesOnEachItem: boolean | null;
-}
-export interface StoreDiscount {
-    id: string;
-    createdAt: string;
-    updatedAt: string;
-    storeId: string;
-    accountId: string;
-    name: string;
-    code: string;
-    automatic: boolean;
-    usageLimit: number | null;
-    usageCount: number;
-    startDate: string;
-    endDate: string | null;
-    enabled: boolean;
-    archived: boolean;
-    ruleOperator: string;
-    externalId: string | null;
-    combinesWithOrderLevelDiscounts: boolean;
-    combinesWithLineItemDiscounts: boolean;
-    combinesWithShippingDiscounts: boolean;
-    forceCombine: boolean;
-    isTemporary: boolean;
-    rules: StoreDiscountRule[];
-    actions: StoreDiscountAction[];
-}
-export interface UseDiscountQueryOptions {
-    storeId?: string;
-    discountId?: string;
-    enabled?: boolean;
-}
-export interface UseDiscountQueryResult<TData = StoreDiscount> {
-    discount: TData | undefined;
-    isLoading: boolean;
-    error: Error | null;
-    refetch: UseQueryResult<TData>['refetch'];
-}
-export declare function useDiscountQuery<TData = StoreDiscount>(options: UseDiscountQueryOptions): UseDiscountQueryResult<TData>;

package/dist/v2/react/hooks/useDiscountQuery.js

@@ -1,24 +0,0 @@
-/**
- * Single Discount Hook using TanStack Query
- * Fetches a specific discount for a given store
- */
-import { useMemo } from 'react';
-import { useApiQuery } from './useApiQuery';
-import { usePluginConfig } from './usePluginConfig';
-export function useDiscountQuery(options) {
-    const { storeId: storeIdFromConfig } = usePluginConfig();
-    const { storeId = storeIdFromConfig, discountId, enabled = true } = options;
-    const key = useMemo(() => ['discount', storeId, discountId], [storeId, discountId]);
-    const url = useMemo(() => {
-        if (!storeId || !discountId)
-            return null;
-        return `/api/v1/stores/${storeId}/discounts/${discountId}`;
-    }, [storeId, discountId]);
-    const query = useApiQuery(key, url, { enabled });
-    return {
-        discount: query.data,
-        isLoading: query.isLoading,
-        error: query.error || null,
-        refetch: query.refetch,
-    };
-}