@commercengine/storefront-sdk 0.3.0 → 0.3.1

package/dist/lib/auth.js

@@ -1,182 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NextCookieTokenStorage = exports.CookieTokenStorage = exports.BrowserTokenStorage = exports.MemoryTokenStorage = exports.AuthClient = void 0;
-exports.createTokenStorage = createTokenStorage;
-const client_1 = require("./client");
+import { StorefrontAPIClient } from "./client";
 /**
  * Client for interacting with authentication endpoints
  */
-class AuthClient extends client_1.StorefrontAPIClient {
-    constructor(config, tokenStorage) {
+export class AuthClient extends StorefrontAPIClient {
+    constructor(config) {
         super(config);
-        this.autoRefreshTimer = null;
-        this.tokenStorage = tokenStorage;
-        this.setupAutoRefresh();
-    }
-    // Override the setToken method to use storage
-    async setToken(token) {
-        super.setToken(token); // Set token in client
-        await this.tokenStorage.setItem("access_token", token);
-        // If we also have a refresh token, store it
-        const refreshToken = await this.tokenStorage.getItem("refresh_token");
-        if (refreshToken) {
-            this.setupAutoRefresh();
-        }
-    }
-    // Store refresh token separately
-    async setRefreshToken(token) {
-        await this.tokenStorage.setItem("refresh_token", token);
-    }
-    // Clear tokens from storage
-    async clearToken() {
-        super.clearToken(); // Clear token in client
-        await this.tokenStorage.removeItem("access_token");
-        await this.tokenStorage.removeItem("refresh_token");
-        await this.tokenStorage.removeItem("user_data");
-        this.clearAutoRefresh();
-    }
-    // Setup auto refresh based on token expiry
-    async setupAutoRefresh() {
-        this.clearAutoRefresh();
-        const token = await this.tokenStorage.getItem("access_token");
-        if (!token)
-            return;
-        const expiryTime = this.getTokenExpiry(token);
-        if (!expiryTime)
-            return;
-        // Calculate refresh time (30 seconds before expiry)
-        const currentTime = Math.floor(Date.now() / 1000);
-        const timeUntilRefresh = Math.max(0, expiryTime - currentTime - 30) * 1000;
-        // Cap the timeout to avoid integer overflow (max 2147483647 ms, ~24.8 days)
-        const maxTimeout = 2147483647;
-        const safeTimeout = Math.min(timeUntilRefresh, maxTimeout);
-        // If the token expires far in the future, we'll need to reset the timer periodically
-        if (timeUntilRefresh > maxTimeout) {
-            this.autoRefreshTimer = setTimeout(() => {
-                this.setupAutoRefresh(); // Recalculate the timer
-            }, maxTimeout);
-        }
-        else {
-            this.autoRefreshTimer = setTimeout(() => {
-                this.handleTokenRefresh();
-            }, safeTimeout);
-        }
-    }
-    clearAutoRefresh() {
-        if (this.autoRefreshTimer) {
-            clearTimeout(this.autoRefreshTimer);
-            this.autoRefreshTimer = null;
-        }
-    }
-    async handleTokenRefresh() {
-        try {
-            const refreshToken = await this.tokenStorage.getItem("refresh_token");
-            if (!refreshToken)
-                return;
-            const tokens = await this.refreshToken(refreshToken);
-            await this.setToken(tokens.access_token);
-            await this.setRefreshToken(tokens.refresh_token);
-        }
-        catch (error) {
-            // If refresh fails, clear tokens
-            await this.clearToken();
-        }
-    }
-    getTokenExpiry(token) {
-        try {
-            // Simple JWT parsing (payload is the middle part between dots)
-            const parts = token.split(".");
-            if (parts.length !== 3)
-                return null;
-            // Base64 decode the payload
-            // We need to fix the base64 padding for the browser's atob function
-            const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
-            const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), "=");
-            // In Node.js
-            let jsonStr;
-            if (typeof Buffer !== "undefined") {
-                jsonStr = Buffer.from(padded, "base64").toString();
-            }
-            // In browser
-            else if (typeof atob !== "undefined") {
-                jsonStr = atob(padded);
-            }
-            // Fallback
-            else {
-                return null;
-            }
-            const payload = JSON.parse(jsonStr);
-            return payload.exp;
-        }
-        catch (error) {
-            console.error("Error parsing JWT token:", error);
-            return null;
-        }
     }
     /**
-     * Store auth data including tokens and user info
-     */
-    async storeAuthData(accessToken, refreshToken, user) {
-        await this.setToken(accessToken);
-        await this.setRefreshToken(refreshToken);
-        if (user) {
-            await this.tokenStorage.setItem("user_data", JSON.stringify(user));
-        }
-    }
-    /**
-     * Get stored user data
-     * @returns Promise that resolves to the stored user data or null if none exists
+     * Get anonymous token for guest users
      */
-    async getStoredUser() {
-        const userData = await this.tokenStorage.getItem("user_data");
-        if (!userData)
-            return null;
-        try {
-            return JSON.parse(userData);
-        }
-        catch {
-            return null;
-        }
+    async getAnonymousToken() {
+        return this.executeRequest(() => this.client.POST("/auth/anonymous"));
     }
     /**
-     * Get anonymous token for guest users
+     * Login with phone number
+     *
+     * @param phoneNumber - Phone number (without country code)
+     * @param countryCode - Country code (defaults to +91)
+     * @param registerIfNotExists - Whether to register if user doesn't exist
+     * @returns Promise with OTP token and action
      */
-    async getAnonymousToken(options) {
-        return this.executeWithTokenRefresh(async () => {
-            const { data, error } = await this.client.POST("/auth/anonymous", {
-                headers: options?.apiKey ? { "X-Api-Key": options.apiKey } : undefined,
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            const response = data?.content;
-            // Store tokens and user data
-            await this.storeAuthData(response.access_token, response.refresh_token, response.user);
-            return response;
-        });
+    async loginWithPhone(body) {
+        return this.executeRequest(() => this.client.POST("/auth/login/phone", {
+            body: body,
+        }));
     }
     /**
-     * Login with phone number
+     * Login with WhatsApp
      *
      * @param phoneNumber - Phone number (without country code)
      * @param countryCode - Country code (defaults to +91)
      * @param registerIfNotExists - Whether to register if user doesn't exist
      * @returns Promise with OTP token and action
      */
-    async loginWithPhone(phoneNumber, countryCode = "+91", registerIfNotExists = false) {
-        return this.executeWithTokenRefresh(async () => {
-            const { data, error } = await this.client.POST("/auth/login/phone", {
-                body: {
-                    phone: phoneNumber,
-                    country_code: countryCode,
-                    register_if_not_exists: registerIfNotExists,
-                },
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            return data?.content;
-        });
+    async loginWithWhatsApp(body) {
+        return this.executeRequest(() => this.client.POST("/auth/login/whatsapp", {
+            body: body,
+        }));
     }
     /**
      * Login with email
@@ -185,19 +45,10 @@ class AuthClient extends client_1.StorefrontAPIClient {
      * @param registerIfNotExists - Whether to register if user doesn't exist
      * @returns Promise with OTP token and action
      */
-    async loginWithEmail(email, registerIfNotExists = false) {
-        return this.executeWithTokenRefresh(async () => {
-            const { data, error } = await this.client.POST("/auth/login/email", {
-                body: {
-                    email,
-                    register_if_not_exists: registerIfNotExists,
-                },
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            return data?.content;
-        });
+    async loginWithEmail(body) {
+        return this.executeRequest(() => this.client.POST("/auth/login/email", {
+            body: body,
+        }));
     }
     /**
      * Login with password
@@ -205,19 +56,45 @@ class AuthClient extends client_1.StorefrontAPIClient {
      * @param credentials - Login credentials
      * @returns Promise with user info and tokens
      */
-    async loginWithPassword(credentials) {
-        return this.executeWithTokenRefresh(async () => {
-            const { data, error } = await this.client.POST("/auth/login/password", {
-                body: credentials,
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            const response = data?.content;
-            // Store tokens and user ID
-            await this.storeAuthData(response.access_token, response.refresh_token, response.user);
-            return response;
-        });
+    async loginWithPassword(body) {
+        return this.executeRequest(() => this.client.POST("/auth/login/password", {
+            body: body,
+        }));
+    }
+    /**
+     * Forgot password
+     *
+     * @param email - Email address
+     * @returns Promise with user info and tokens
+     */
+    async forgotPassword(body) {
+        return this.executeRequest(() => this.client.POST("/auth/forgot-password", {
+            body: body,
+        }));
+    }
+    /**
+     * Reset password
+     *
+     * @param email - Email address
+     * @returns Promise with user info and tokens
+     */
+    async resetPassword(body) {
+        return this.executeRequest(() => this.client.POST("/auth/reset-password", {
+            body: body,
+        }));
+    }
+    /**
+     * Change password
+     *
+     * @param oldPassword - Old password
+     * @param newPassword - New password
+     * @param newPasswordConfirmation - New password confirmation
+     * @returns Promise with new access token and refresh token
+     */
+    async changePassword(body) {
+        return this.executeRequest(() => this.client.POST("/auth/change-password", {
+            body: body,
+        }));
     }
     /**
      * Verify OTP
@@ -227,24 +104,10 @@ class AuthClient extends client_1.StorefrontAPIClient {
      * @param otpAction - OTP action from login request
      * @returns Promise with user info and tokens
      */
-    async verifyOtp(otp, otpToken, otpAction) {
-        return this.executeWithTokenRefresh(async () => {
-            const { data, error } = await this.client.POST("/auth/verify-otp", {
-                body: {
-                    otp,
-                    otp_token: otpToken,
-                    otp_action: otpAction,
-                },
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            if (data?.content?.access_token && data?.content?.refresh_token) {
-                await this.setToken(data.content.access_token);
-                await this.setRefreshToken(data.content.refresh_token);
-            }
-            return data?.content;
-        });
+    async verifyOtp(body) {
+        return this.executeRequest(() => this.client.POST("/auth/verify-otp", {
+            body: body,
+        }));
     }
     /**
      * Register with phone
@@ -252,23 +115,10 @@ class AuthClient extends client_1.StorefrontAPIClient {
      * @param options - Registration details
      * @returns Promise with user info and tokens
      */
-    async registerWithPhone(options) {
-        return this.executeWithTokenRefresh(async () => {
-            const { data, error } = await this.client.POST("/auth/register/phone", {
-                body: {
-                    ...options,
-                    country_code: options.country_code,
-                },
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            if (data?.content?.access_token && data?.content?.refresh_token) {
-                await this.setToken(data.content.access_token);
-                await this.setRefreshToken(data.content.refresh_token);
-            }
-            return data?.content;
-        });
+    async registerWithPhone(body) {
+        return this.executeRequest(() => this.client.POST("/auth/register/phone", {
+            body: body,
+        }));
     }
     /**
      * Register with email
@@ -276,35 +126,20 @@ class AuthClient extends client_1.StorefrontAPIClient {
      * @param options - Registration details
      * @returns Promise with user info and tokens
      */
-    async registerWithEmail(options) {
-        return this.executeWithTokenRefresh(async () => {
-            const { data, error } = await this.client.POST("/auth/register/email", {
-                body: options,
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            if (data?.content?.access_token && data?.content?.refresh_token) {
-                await this.setToken(data.content.access_token);
-                await this.setRefreshToken(data.content.refresh_token);
-            }
-            return data?.content;
-        });
+    async registerWithEmail(body) {
+        return this.executeRequest(() => this.client.POST("/auth/register/email", {
+            body: body,
+        }));
     }
     /**
      * Refresh the access token using a refresh token
+     * @param refreshToken - The refresh token to use for refreshing the access token
+     * @returns Promise with the new access token and refresh token
      */
-    async refreshToken(refreshToken) {
-        const { data, error } = await this.client.POST("/auth/refresh-token", {
-            body: { refresh_token: refreshToken },
-        });
-        if (error) {
-            this.handleError(error);
-        }
-        const response = data?.content;
-        // Store new tokens but don't update user ID as it hasn't changed
-        await this.storeAuthData(response.access_token, response.refresh_token);
-        return response;
+    async refreshToken(body) {
+        return this.executeRequest(() => this.client.POST("/auth/refresh-token", {
+            body: body,
+        }));
     }
     /**
      * Logout
@@ -312,445 +147,181 @@ class AuthClient extends client_1.StorefrontAPIClient {
      * @returns Promise that resolves when logout is complete
      */
     async logout() {
-        return this.executeWithTokenRefresh(async () => {
-            const { error } = await this.client.POST("/auth/logout");
-            if (error) {
-                this.handleError(error);
-            }
-            await this.clearToken();
-        });
+        return this.executeRequest(() => this.client.POST("/auth/logout"));
     }
     /**
-     * Override the base client's attemptTokenRefresh method
-     * to implement token refresh for 401 errors
+     * Get user details
      *
-     * @returns Promise that resolves to true if token was refreshed, false otherwise
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    async attemptTokenRefresh() {
-        const refreshToken = await this.tokenStorage.getItem("refresh_token");
-        if (!refreshToken)
-            return false;
-        try {
-            // Get current user data before refresh
-            const userData = await this.getStoredUser();
-            const tokens = await this.refreshToken(refreshToken);
-            if (tokens.access_token) {
-                await this.setToken(tokens.access_token);
-            }
-            if (tokens.refresh_token) {
-                await this.setRefreshToken(tokens.refresh_token);
-            }
-            // Restore user data after refresh since it hasn't changed
-            if (userData) {
-                await this.tokenStorage.setItem("user_data", JSON.stringify(userData));
-            }
-            return true;
-        }
-        catch (error) {
-            // If refresh fails, clear tokens
-            await this.clearToken();
-            return false;
-        }
+    async getUserDetails(pathParams) {
+        return this.executeRequest(() => this.client.GET("/auth/user/{id}", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Execute a request with automatic token refresh handling
-     * This wraps any API call in logic that will catch authentication errors,
-     * attempt to refresh the token, and retry the request once
+     * Update user details
      *
-     * @param requestFn - Function that executes the API request
-     * @returns Promise with the API response
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    async executeWithTokenRefresh(requestFn) {
-        try {
-            // Attempt the request
-            return await requestFn();
-        }
-        catch (error) {
-            // If error message indicates token was refreshed, retry the request
-            if (error instanceof Error &&
-                error.message === "Token refreshed, please retry the request") {
-                return await requestFn();
-            }
-            // Otherwise, re-throw the error
-            throw error;
-        }
-    }
-}
-exports.AuthClient = AuthClient;
-/**
- * Default in-memory implementation of client storage
- */
-class MemoryTokenStorage {
-    constructor() {
-        this.accessToken = null;
-        this.refreshToken = null;
-        this.cartId = null;
-        this.userData = null;
-    }
-    getItem(key) {
-        if (key === "access_token")
-            return Promise.resolve(this.accessToken);
-        if (key === "refresh_token")
-            return Promise.resolve(this.refreshToken);
-        if (key === "cart_id")
-            return Promise.resolve(this.cartId);
-        if (key === "user_data")
-            return Promise.resolve(this.userData);
-        return Promise.resolve(null);
-    }
-    setItem(key, value) {
-        if (key === "access_token")
-            this.accessToken = value;
-        if (key === "refresh_token")
-            this.refreshToken = value;
-        if (key === "cart_id")
-            this.cartId = value;
-        if (key === "user_data")
-            this.userData = value;
-        return Promise.resolve();
-    }
-    removeItem(key) {
-        if (key === "access_token")
-            this.accessToken = null;
-        if (key === "refresh_token")
-            this.refreshToken = null;
-        if (key === "cart_id")
-            this.cartId = null;
-        if (key === "user_data")
-            this.userData = null;
-        return Promise.resolve();
-    }
-    getCartId() {
-        return Promise.resolve(this.cartId);
-    }
-    setCartId(cartId) {
-        this.cartId = cartId;
-        return Promise.resolve();
-    }
-    clearCartId() {
-        this.cartId = null;
-        return Promise.resolve();
-    }
-}
-exports.MemoryTokenStorage = MemoryTokenStorage;
-/**
- * Browser storage implementation using localStorage
- */
-class BrowserTokenStorage {
-    constructor(prefix = "storefront_") {
-        this.accessTokenKey = `${prefix}access_token`;
-        this.refreshTokenKey = `${prefix}refresh_token`;
-        this.cartIdKey = `${prefix}cart_id`;
-        this.userDataKey = `${prefix}user_data`;
-    }
-    getItem(key) {
-        if (key === "access_token")
-            return Promise.resolve(localStorage.getItem(this.accessTokenKey));
-        if (key === "refresh_token")
-            return Promise.resolve(localStorage.getItem(this.refreshTokenKey));
-        if (key === "cart_id")
-            return Promise.resolve(localStorage.getItem(this.cartIdKey));
-        if (key === "user_data")
-            return Promise.resolve(localStorage.getItem(this.userDataKey));
-        return Promise.resolve(null);
-    }
-    setItem(key, value) {
-        if (key === "access_token")
-            localStorage.setItem(this.accessTokenKey, value);
-        if (key === "refresh_token")
-            localStorage.setItem(this.refreshTokenKey, value);
-        if (key === "cart_id")
-            localStorage.setItem(this.cartIdKey, value);
-        if (key === "user_data")
-            localStorage.setItem(this.userDataKey, value);
-        return Promise.resolve();
-    }
-    removeItem(key) {
-        if (key === "access_token")
-            localStorage.removeItem(this.accessTokenKey);
-        if (key === "refresh_token")
-            localStorage.removeItem(this.refreshTokenKey);
-        if (key === "cart_id")
-            localStorage.removeItem(this.cartIdKey);
-        if (key === "user_data")
-            localStorage.removeItem(this.userDataKey);
-        return Promise.resolve();
-    }
-    getCartId() {
-        return Promise.resolve(localStorage.getItem(this.cartIdKey));
-    }
-    setCartId(cartId) {
-        localStorage.setItem(this.cartIdKey, cartId);
-        return Promise.resolve();
-    }
-    clearCartId() {
-        localStorage.removeItem(this.cartIdKey);
-        return Promise.resolve();
-    }
-}
-exports.BrowserTokenStorage = BrowserTokenStorage;
-/**
- * Cookie-based token storage for browser or server environments
- */
-class CookieTokenStorage {
-    constructor(prefix = "storefront_", cookieOptions = {
-        path: "/",
-        secure: true,
-        sameSite: "lax",
-        httpOnly: true,
-        maxAge: 60 * 60 * 24 * 30, // 30 days
-    }) {
-        this.accessTokenKey = `${prefix}access_token`;
-        this.refreshTokenKey = `${prefix}refresh_token`;
-        this.cartIdKey = `${prefix}cart_id`;
-        this.userDataKey = `${prefix}user_data`;
-        this.cookieOptions = cookieOptions;
+    async updateUserDetails(pathParams, body) {
+        return this.executeRequest(() => this.client.PUT("/auth/user/{id}", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
     }
     /**
-     * Get value from cookies
-     * Works in both browser and Next.js server components
+     * Add profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    getItem(key) {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            if (key === "access_token")
-                return Promise.resolve(getCookieValue(this.accessTokenKey));
-            if (key === "refresh_token")
-                return Promise.resolve(getCookieValue(this.refreshTokenKey));
-            if (key === "cart_id")
-                return Promise.resolve(getCookieValue(this.cartIdKey));
-            if (key === "user_data")
-                return Promise.resolve(getCookieValue(this.userDataKey));
-        }
-        // Next.js server component - would need to be implemented by user
-        return Promise.resolve(null);
+    async addProfileImage(pathParams, formData) {
+        return this.executeRequest(() => this.client.POST("/auth/user/{id}/profile-image", {
+            params: {
+                path: pathParams,
+            },
+            body: formData,
+            bodySerializer: (body) => {
+                const fd = new FormData();
+                for (const [key, value] of Object.entries(body)) {
+                    if (value !== undefined && value !== null) {
+                        fd.append(key, value);
+                    }
+                }
+                return fd;
+            }
+        }));
     }
     /**
-     * Set value in cookies
-     * Works in browser environment
+     * Update profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    setItem(key, value) {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            if (key === "access_token")
-                setCookie(this.accessTokenKey, value, this.cookieOptions);
-            if (key === "refresh_token")
-                setCookie(this.refreshTokenKey, value, this.cookieOptions);
-            if (key === "cart_id")
-                setCookie(this.cartIdKey, value, this.cookieOptions);
-            if (key === "user_data")
-                setCookie(this.userDataKey, value, this.cookieOptions);
-        }
-        // Next.js - would need to be implemented by user
-        return Promise.resolve();
+    async updateProfileImage(pathParams, formData) {
+        return this.executeRequest(() => this.client.PUT("/auth/user/{id}/profile-image", {
+            params: {
+                path: pathParams,
+            },
+            body: formData,
+            bodySerializer: (body) => {
+                const fd = new FormData();
+                for (const [key, value] of Object.entries(body)) {
+                    if (value !== undefined && value !== null) {
+                        fd.append(key, value);
+                    }
+                }
+                return fd;
+            }
+        }));
     }
     /**
-     * Remove value from cookies
+     * Delete profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    removeItem(key) {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            if (key === "access_token")
-                deleteCookie(this.accessTokenKey);
-            if (key === "refresh_token")
-                deleteCookie(this.refreshTokenKey);
-            if (key === "cart_id")
-                deleteCookie(this.cartIdKey);
-            if (key === "user_data")
-                deleteCookie(this.userDataKey);
-        }
-        // Next.js - would need to be implemented by user
-        return Promise.resolve();
+    async deleteProfileImage(pathParams) {
+        return this.executeRequest(() => this.client.DELETE("/auth/user/{id}/profile-image", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Get cart ID from cookies
+     * Get profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    getCartId() {
-        return this.getItem(this.cartIdKey);
+    async getProfileImage(pathParams) {
+        return this.executeRequest(() => this.client.GET("/auth/user/{id}/profile-image", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Set cart ID in cookies
+     * Deactivate user account
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    setCartId(cartId) {
-        return this.setItem(this.cartIdKey, cartId);
+    async deactivateUserAccount(pathParams) {
+        return this.executeRequest(() => this.client.PUT("/auth/user/{id}/deactivate", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Clear cart ID from cookies
+     * Get user notification preferences
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    clearCartId() {
-        return this.removeItem(this.cartIdKey);
-    }
-}
-exports.CookieTokenStorage = CookieTokenStorage;
-/**
- * Next.js specific cookie storage implementation
- * Works with the Next.js cookies API
- */
-class NextCookieTokenStorage {
-    constructor(cookieStore, prefix = "storefront_") {
-        this.accessTokenKey = `${prefix}access_token`;
-        this.refreshTokenKey = `${prefix}refresh_token`;
-        this.cartIdKey = `${prefix}cart_id`;
-        this.userDataKey = `${prefix}user_data`;
-        this.cookieStore = cookieStore;
-    }
-    getItem(key) {
-        try {
-            // Assuming cookieStore.get method exists (like in next/headers)
-            let cookieKey = "";
-            if (key === "access_token")
-                cookieKey = this.accessTokenKey;
-            if (key === "refresh_token")
-                cookieKey = this.refreshTokenKey;
-            if (key === "cart_id")
-                cookieKey = this.cartIdKey;
-            if (key === "user_data")
-                cookieKey = this.userDataKey;
-            if (!cookieKey)
-                return Promise.resolve(null);
-            const cookie = this.cookieStore.get(cookieKey);
-            return cookie ? Promise.resolve(cookie.value) : Promise.resolve(null);
-        }
-        catch (error) {
-            return Promise.resolve(null);
-        }
-    }
-    setItem(key, value) {
-        try {
-            // Assuming cookieStore.set method exists
-            let cookieKey = "";
-            if (key === "access_token")
-                cookieKey = this.accessTokenKey;
-            if (key === "refresh_token")
-                cookieKey = this.refreshTokenKey;
-            if (key === "cart_id")
-                cookieKey = this.cartIdKey;
-            if (key === "user_data")
-                cookieKey = this.userDataKey;
-            if (!cookieKey)
-                return Promise.resolve();
-            this.cookieStore.set(cookieKey, value, {
-                path: "/",
-                secure: process.env.NODE_ENV === "production",
-                httpOnly: true,
-                sameSite: "strict",
-                maxAge: 60 * 60 * 24 * 30, // 30 days
-            });
-            return Promise.resolve();
-        }
-        catch (error) {
-            // Silently fail - might be in an environment where cookies can't be set
-            return Promise.resolve();
-        }
-    }
-    removeItem(key) {
-        try {
-            // Assuming cookieStore.delete method exists
-            let cookieKey = "";
-            if (key === "access_token")
-                cookieKey = this.accessTokenKey;
-            if (key === "refresh_token")
-                cookieKey = this.refreshTokenKey;
-            if (key === "cart_id")
-                cookieKey = this.cartIdKey;
-            if (key === "user_data")
-                cookieKey = this.userDataKey;
-            if (!cookieKey)
-                return Promise.resolve();
-            this.cookieStore.delete(cookieKey);
-            return Promise.resolve();
-        }
-        catch (error) {
-            // Silently fail
-            return Promise.resolve();
-        }
+    async getUserNotificationPreferences(pathParams) {
+        return this.executeRequest(() => this.client.GET("/auth/user/{id}/notification-preferences", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Get cart ID from Next.js cookies
+     * Update user notification preferences
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    getCartId() {
-        return this.getItem(this.cartIdKey);
+    async updateUserNotificationPreferences(pathParams, body) {
+        return this.executeRequest(() => this.client.PUT("/auth/user/{id}/notification-preferences", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
     }
     /**
-     * Set cart ID in Next.js cookies
+     * Create user notification preference
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    setCartId(cartId) {
-        return this.setItem(this.cartIdKey, cartId);
+    async createUserNotificationPreference(pathParams, body) {
+        return this.executeRequest(() => this.client.POST("/auth/user/{id}/notification-preferences", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
     }
     /**
-     * Clear cart ID from Next.js cookies
+     * Generate OTP
+     *
+     * @param body - OTP generation body
+     * @returns Promise with OTP generation response
      */
-    clearCartId() {
-        return this.removeItem(this.cartIdKey);
-    }
-}
-exports.NextCookieTokenStorage = NextCookieTokenStorage;
-/**
- * Helper function to get cookie value
- */
-function getCookieValue(name) {
-    if (typeof document === "undefined")
-        return null;
-    const match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"));
-    return match ? decodeURIComponent(match[2]) : null;
-}
-/**
- * Helper function to set cookie
- */
-function setCookie(name, value, options = {}) {
-    if (typeof document === "undefined")
-        return;
-    const cookieOptions = {
-        path: "/",
-        ...options,
-    };
-    let cookie = `${name}=${encodeURIComponent(value)}`;
-    if (cookieOptions.maxAge) {
-        cookie += `; max-age=${cookieOptions.maxAge}`;
-    }
-    if (cookieOptions.domain) {
-        cookie += `; domain=${cookieOptions.domain}`;
+    async generateOtp(body) {
+        return this.executeRequest(() => this.client.POST("/auth/generate-otp", {
+            body: body,
+        }));
     }
-    if (cookieOptions.path) {
-        cookie += `; path=${cookieOptions.path}`;
-    }
-    if (cookieOptions.secure) {
-        cookie += "; secure";
-    }
-    if (cookieOptions.sameSite) {
-        cookie += `; samesite=${cookieOptions.sameSite}`;
-    }
-    document.cookie = cookie;
-}
-/**
- * Helper function to delete cookie
- */
-function deleteCookie(name, path = "/") {
-    if (typeof document === "undefined")
-        return;
-    document.cookie = `${name}=; path=${path}; expires=Thu, 01 Jan 1970 00:00:01 GMT`;
-}
-/**
- * Helper to create a token storage instance based on environment
- * Automatically selects the best storage method based on context
- */
-function createTokenStorage(options) {
-    const prefix = options?.prefix || "storefront_";
-    // Node.js environment without a cookieStore - use memory
-    if (typeof window === "undefined" && !options?.cookieStore) {
-        return new MemoryTokenStorage();
-    }
-    // Next.js server component with cookieStore
-    if (typeof window === "undefined" && options?.cookieStore) {
-        return new NextCookieTokenStorage(options.cookieStore, prefix);
-    }
-    // Browser environment - use localStorage by default unless cookies are specified
-    if (typeof window !== "undefined") {
-        if (options?.useLocalStorage === false) {
-            return new CookieTokenStorage(prefix);
-        }
-        return new BrowserTokenStorage(prefix);
+    /**
+     * Check whether email or phone is already verified
+     *
+     * @param body - OTP generation body
+     * @returns Promise with OTP generation response
+     */
+    async checkEmailOrPhoneIsVerified(body) {
+        return this.executeRequest(() => this.client.POST("/auth/verified-email-phone", {
+            body: body,
+        }));
     }
-    // Fallback to memory storage
-    return new MemoryTokenStorage();
 }