@commercengine/storefront-sdk 0.2.1 → 0.3.1

package/dist/lib/auth.js

@@ -1,187 +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;
-        // Use provided storage or default to memory storage
-        this.tokenStorage = tokenStorage || new MemoryTokenStorage();
-        // Try to initialize from storage
-        const storedToken = this.tokenStorage.getAccessToken();
-        if (storedToken) {
-            this.setToken(storedToken);
-            this.setupAutoRefresh();
-        }
     }
-    // Override the setToken method to use storage
-    setToken(token) {
-        super.setToken(token); // Assuming this sets the token in the client
-        this.tokenStorage.setAccessToken(token);
-        // If we also have a refresh token, store it
-        if (this.tokenStorage.getRefreshToken()) {
-            this.setupAutoRefresh();
-        }
-    }
-    // Store refresh token separately
-    setRefreshToken(token) {
-        this.tokenStorage.setRefreshToken(token);
-    }
-    // Clear tokens from storage
-    clearToken() {
-        super.clearToken(); // Assuming this clears the token in the client
-        this.tokenStorage.clearTokens();
-        this.clearAutoRefresh();
-    }
-    // Setup auto refresh based on token expiry
-    setupAutoRefresh() {
-        this.clearAutoRefresh();
-        const token = this.tokenStorage.getAccessToken();
-        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 = this.tokenStorage.getRefreshToken();
-            if (!refreshToken)
-                return;
-            const tokens = await this.refreshToken(refreshToken);
-            this.setToken(tokens.access_token);
-            this.setRefreshToken(tokens.refresh_token);
-        }
-        catch (error) {
-            // If refresh fails, clear tokens
-            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;
-        }
+    /**
+     * Get anonymous token for guest users
+     */
+    async getAnonymousToken() {
+        return this.executeRequest(() => this.client.POST("/auth/anonymous"));
     }
     /**
-     * Get an anonymous user token
+     * Login with phone number
      *
-     * @param options - Options for anonymous authentication
-     * @returns Promise with user info and tokens
+     * @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 () => {
-            // If apiKey is provided in options, temporarily set it for this request only
-            const tempApiKey = options?.apiKey;
-            const hadExistingApiKey = !!this.config.apiKey;
-            const originalApiKey = this.config.apiKey;
-            try {
-                // Set temporary API key if provided
-                if (tempApiKey) {
-                    this.setApiKey(tempApiKey);
-                }
-                // Check if we have an API key set (either from constructor or from options)
-                if (!this.config.apiKey) {
-                    throw new Error("X-Api-Key is required for anonymous authentication");
-                }
-                const { data, error } = await this.client.POST("/auth/anonymous");
-                if (error) {
-                    this.handleError(error);
-                }
-                if (data?.content?.access_token && data?.content?.refresh_token) {
-                    this.setToken(data.content.access_token);
-                    this.setRefreshToken(data.content.refresh_token);
-                }
-                return data?.content;
-            }
-            finally {
-                // Restore the original API key state if we used a temporary one
-                if (tempApiKey) {
-                    if (hadExistingApiKey && originalApiKey) {
-                        this.setApiKey(originalApiKey);
-                    }
-                    else {
-                        this.clearApiKey();
-                    }
-                }
-            }
-        });
+    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
@@ -190,40 +45,56 @@ 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
      *
-     * @param options - Login credentials
+     * @param credentials - Login credentials
      * @returns Promise with user info and tokens
      */
-    async loginWithPassword(options) {
-        return this.executeWithTokenRefresh(async () => {
-            const { data, error } = await this.client.POST("/auth/login/password", {
-                body: options,
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            if (data?.content?.access_token && data?.content?.refresh_token) {
-                this.setToken(data.content.access_token);
-                this.setRefreshToken(data.content.refresh_token);
-            }
-            return data?.content;
-        });
+    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
@@ -233,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) {
-                this.setToken(data.content.access_token);
-                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
@@ -258,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) {
-                this.setToken(data.content.access_token);
-                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
@@ -282,42 +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) {
-                this.setToken(data.content.access_token);
-                this.setRefreshToken(data.content.refresh_token);
-            }
-            return data?.content;
-        });
+    async registerWithEmail(body) {
+        return this.executeRequest(() => this.client.POST("/auth/register/email", {
+            body: body,
+        }));
     }
     /**
-     * Refresh token
-     *
-     * @param refreshToken - Refresh token
-     * @returns Promise with new tokens
+     * 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) {
-        // Don't use executeWithTokenRefresh here to avoid infinite loop
-        const { data, error } = await this.client.POST("/auth/refresh-token", {
-            body: {
-                refresh_token: refreshToken,
-            },
-        });
-        if (error) {
-            this.handleError(error);
-        }
-        if (data?.content?.access_token && data?.content?.refresh_token) {
-            this.setToken(data.content.access_token);
-            this.setRefreshToken(data.content.refresh_token);
-        }
-        return data?.content;
+    async refreshToken(body) {
+        return this.executeRequest(() => this.client.POST("/auth/refresh-token", {
+            body: body,
+        }));
     }
     /**
      * Logout
@@ -325,460 +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);
-            }
-            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 = this.tokenStorage.getRefreshToken();
-        if (!refreshToken)
-            return false;
-        try {
-            const tokens = await this.refreshToken(refreshToken);
-            if (tokens.access_token) {
-                this.setToken(tokens.access_token);
-            }
-            if (tokens.refresh_token) {
-                this.setRefreshToken(tokens.refresh_token);
-            }
-            return true;
-        }
-        catch (error) {
-            // If refresh fails, clear tokens
-            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;
-    }
-    getAccessToken() {
-        return this.accessToken;
-    }
-    setAccessToken(token) {
-        this.accessToken = token;
-    }
-    getRefreshToken() {
-        return this.refreshToken;
-    }
-    setRefreshToken(token) {
-        this.refreshToken = token;
-    }
-    clearTokens() {
-        this.accessToken = null;
-        this.refreshToken = null;
-    }
-    getCartId() {
-        return this.cartId;
-    }
-    setCartId(cartId) {
-        this.cartId = cartId;
-    }
-    clearCartId() {
-        this.cartId = null;
-    }
-}
-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`;
-    }
-    getAccessToken() {
-        if (typeof localStorage === "undefined")
-            return null;
-        return localStorage.getItem(this.accessTokenKey);
-    }
-    setAccessToken(token) {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.setItem(this.accessTokenKey, token);
-    }
-    getRefreshToken() {
-        if (typeof localStorage === "undefined")
-            return null;
-        return localStorage.getItem(this.refreshTokenKey);
-    }
-    setRefreshToken(token) {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.setItem(this.refreshTokenKey, token);
-    }
-    clearTokens() {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.removeItem(this.accessTokenKey);
-        localStorage.removeItem(this.refreshTokenKey);
-    }
-    getCartId() {
-        if (typeof localStorage === "undefined")
-            return null;
-        return localStorage.getItem(this.cartIdKey);
-    }
-    setCartId(cartId) {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.setItem(this.cartIdKey, cartId);
-    }
-    clearCartId() {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.removeItem(this.cartIdKey);
-    }
-}
-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.cookieOptions = cookieOptions;
-    }
-    /**
-     * Get access token from cookies
-     * Works in both browser and Next.js server components
-     */
-    getAccessToken() {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            return getCookieValue(this.accessTokenKey);
-        }
-        // Next.js server component - would need to be implemented by user
-        // with their specific cookie library
-        return null;
-    }
-    /**
-     * Set access token in cookies
-     * Works in browser environment
-     */
-    setAccessToken(token) {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            setCookie(this.accessTokenKey, token, this.cookieOptions);
-        }
-        // Next.js - would need to be implemented by user
-        // with their specific cookie API
-    }
-    /**
-     * Get refresh token from cookies
-     * Works in both browser and Next.js server components
-     */
-    getRefreshToken() {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            return getCookieValue(this.refreshTokenKey);
-        }
-        // Next.js server component - would need to be implemented by user
-        return null;
-    }
-    /**
-     * Set refresh token in cookies
-     * Works in browser environment
-     */
-    setRefreshToken(token) {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            setCookie(this.refreshTokenKey, token, this.cookieOptions);
-        }
-        // Next.js - would need to be implemented by user
-    }
-    /**
-     * Clear all tokens from cookies
-     */
-    clearTokens() {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            deleteCookie(this.accessTokenKey);
-            deleteCookie(this.refreshTokenKey);
-        }
-        // Next.js - would need to be implemented by user
-    }
-    /**
-     * Get cart ID from cookies
-     * Works in both browser and Next.js server components
-     */
-    getCartId() {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            return getCookieValue(this.cartIdKey);
-        }
-        // Next.js server component - would need to be implemented by user
-        return null;
+    async updateUserDetails(pathParams, body) {
+        return this.executeRequest(() => this.client.PUT("/auth/user/{id}", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
     }
     /**
-     * Set cart ID in cookies
-     * Works in browser environment
+     * Add profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    setCartId(cartId) {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            setCookie(this.cartIdKey, cartId, this.cookieOptions);
-        }
-        // Next.js - would need to be implemented by user
+    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;
+            }
+        }));
     }
     /**
-     * Clear cart ID from cookies
+     * Update profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    clearCartId() {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            deleteCookie(this.cartIdKey);
-        }
-        // Next.js - would need to be implemented by user
-    }
-}
-exports.CookieTokenStorage = CookieTokenStorage;
-/**
- * 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}`;
-    }
-    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`;
-}
-/**
- * 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.cookieStore = cookieStore;
+    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;
+            }
+        }));
     }
     /**
-     * Get access token from Next.js cookies
+     * Delete profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    getAccessToken() {
-        try {
-            // Assuming cookieStore.get method exists (like in next/headers)
-            const cookie = this.cookieStore.get(this.accessTokenKey);
-            return cookie ? cookie.value : null;
-        }
-        catch (error) {
-            return null;
-        }
+    async deleteProfileImage(pathParams) {
+        return this.executeRequest(() => this.client.DELETE("/auth/user/{id}/profile-image", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Set access token in Next.js cookies
+     * Get profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    setAccessToken(token) {
-        try {
-            // Assuming cookieStore.set method exists
-            this.cookieStore.set(this.accessTokenKey, token, {
-                path: "/",
-                secure: process.env.NODE_ENV === "production",
-                httpOnly: true,
-                sameSite: "strict",
-                maxAge: 60 * 60 * 24 * 30, // 30 days
-            });
-        }
-        catch (error) {
-            // Silently fail - might be in an environment where cookies can't be set
-        }
+    async getProfileImage(pathParams) {
+        return this.executeRequest(() => this.client.GET("/auth/user/{id}/profile-image", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Get refresh token from Next.js cookies
+     * Deactivate user account
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    getRefreshToken() {
-        try {
-            // Assuming cookieStore.get method exists
-            const cookie = this.cookieStore.get(this.refreshTokenKey);
-            return cookie ? cookie.value : null;
-        }
-        catch (error) {
-            return null;
-        }
+    async deactivateUserAccount(pathParams) {
+        return this.executeRequest(() => this.client.PUT("/auth/user/{id}/deactivate", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Set refresh token in Next.js cookies
+     * Get user notification preferences
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    setRefreshToken(token) {
-        try {
-            // Assuming cookieStore.set method exists
-            this.cookieStore.set(this.refreshTokenKey, token, {
-                path: "/",
-                secure: process.env.NODE_ENV === "production",
-                httpOnly: true,
-                sameSite: "strict",
-                maxAge: 60 * 60 * 24 * 30, // 30 days
-            });
-        }
-        catch (error) {
-            // Silently fail
-        }
+    async getUserNotificationPreferences(pathParams) {
+        return this.executeRequest(() => this.client.GET("/auth/user/{id}/notification-preferences", {
+            params: {
+                path: pathParams,
+            },
+        }));
     }
     /**
-     * Clear all tokens from Next.js cookies
+     * Update user notification preferences
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    clearTokens() {
-        try {
-            // Assuming cookieStore.delete method exists
-            this.cookieStore.delete(this.accessTokenKey);
-            this.cookieStore.delete(this.refreshTokenKey);
-        }
-        catch (error) {
-            // Silently fail
-        }
+    async updateUserNotificationPreferences(pathParams, body) {
+        return this.executeRequest(() => this.client.PUT("/auth/user/{id}/notification-preferences", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
     }
     /**
-     * Get cart ID from Next.js cookies
+     * Create user notification preference
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
      */
-    getCartId() {
-        try {
-            // Assuming cookieStore.get method exists
-            const cookie = this.cookieStore.get(this.cartIdKey);
-            return cookie ? cookie.value : null;
-        }
-        catch (error) {
-            return null;
-        }
+    async createUserNotificationPreference(pathParams, body) {
+        return this.executeRequest(() => this.client.POST("/auth/user/{id}/notification-preferences", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
     }
     /**
-     * Set cart ID in Next.js cookies
+     * Generate OTP
+     *
+     * @param body - OTP generation body
+     * @returns Promise with OTP generation response
      */
-    setCartId(cartId) {
-        try {
-            // Assuming cookieStore.set method exists
-            this.cookieStore.set(this.cartIdKey, cartId, {
-                path: "/",
-                secure: process.env.NODE_ENV === "production",
-                httpOnly: true,
-                sameSite: "strict",
-                maxAge: 60 * 60 * 24 * 30, // 30 days
-            });
-        }
-        catch (error) {
-            // Silently fail
-        }
+    async generateOtp(body) {
+        return this.executeRequest(() => this.client.POST("/auth/generate-otp", {
+            body: body,
+        }));
     }
     /**
-     * Clear cart ID from Next.js cookies
+     * Check whether email or phone is already verified
+     *
+     * @param body - OTP generation body
+     * @returns Promise with OTP generation response
      */
-    clearCartId() {
-        try {
-            // Assuming cookieStore.delete method exists
-            this.cookieStore.delete(this.cartIdKey);
-        }
-        catch (error) {
-            // Silently fail
-        }
-    }
-}
-exports.NextCookieTokenStorage = NextCookieTokenStorage;
-/**
- * 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);
+    async checkEmailOrPhoneIsVerified(body) {
+        return this.executeRequest(() => this.client.POST("/auth/verified-email-phone", {
+            body: body,
+        }));
     }
-    // Fallback to memory storage
-    return new MemoryTokenStorage();
 }