@memberstack/dom 2.0.1 → 2.0.2-beta.0

package/lib/methods/requests/index.mjs

@@ -43,7 +43,7 @@ import axios from "axios";
 
 // src/constants/endpoints.ts
 var endpoints = {
-  API: "https://client.memberstack.com"
+  API: "http://localhost:3005"
 };
 
 // src/utils/cookies.ts
@@ -61,10 +61,11 @@ function isLocalStorageAvailable() {
 var localStorageAvailable = isLocalStorageAvailable();
 var useCookies = false;
 var setCookieOnRootDomain = false;
-var apiDomain;
+var apiDomain = "";
 var extractDomainFromHostname = (hostname) => {
+  var _a, _b;
   const hostnameParts = hostname.split(".");
-  const isCountryCodeTLD = hostnameParts.length >= 3 && hostnameParts[hostnameParts.length - 2].length <= 3;
+  const isCountryCodeTLD = hostnameParts.length >= 4 && ((_b = (_a = hostnameParts[hostnameParts.length - 2]) == null ? void 0 : _a.length) != null ? _b : 0) <= 3;
   if (isCountryCodeTLD) {
     return hostnameParts.slice(-3).join(".");
   } else {
@@ -186,9 +187,10 @@ var createRequestHandler = ({
         }
         return res == null ? void 0 : res.data;
       } catch (e) {
-        if (!e.response)
+        const error = e;
+        if (!error.response)
           throw e;
-        throw ((_g = (_f = e.response) == null ? void 0 : _f.data) == null ? void 0 : _g.error) || ((_h = e.response) == null ? void 0 : _h.data);
+        throw ((_g = (_f = error.response) == null ? void 0 : _f.data) == null ? void 0 : _g.error) || ((_h = error.response) == null ? void 0 : _h.data);
       }
     }),
     sendRequestWithFetch: (data, options) => __async(void 0, null, function* () {
@@ -266,7 +268,8 @@ var createObservable = () => {
 };
 var observable = createObservable();
 var getPersistedMember = () => {
-  return JSON.parse(localStorage == null ? void 0 : localStorage.getItem("_ms-mem"));
+  const stored = localStorage == null ? void 0 : localStorage.getItem("_ms-mem");
+  return stored ? JSON.parse(stored) : null;
 };
 var setPersistedMember = (member) => {
   if (member) {
@@ -299,9 +302,12 @@ function getSessionDurationDays(unixTimestampMillis) {
   const differenceMillis = unixTimestampMillis - now;
   return Math.ceil(differenceMillis / (24 * 60 * 60 * 1e3));
 }
-var addHeaders = (options) => __spreadValues({}, (options == null ? void 0 : options.token) && {
-  Authorization: `Bearer ${options.token}`
-});
+var addHeaders = (options) => {
+  const opts = options;
+  return __spreadValues({}, (opts == null ? void 0 : opts.token) && {
+    Authorization: `Bearer ${opts.token}`
+  });
+};
 var promiseResolve;
 var promiseReject;
 var receiveMessage = (event) => {
@@ -315,9 +321,9 @@ var receiveMessage = (event) => {
     setMemberToken(data.data.tokens.accessToken, sessionDurationDays);
   }
   if (data == null ? void 0 : data.error) {
-    promiseReject(data.error);
+    promiseReject == null ? void 0 : promiseReject(data.error);
   }
-  promiseResolve(data);
+  promiseResolve == null ? void 0 : promiseResolve(data);
 };
 var windowObjectReference = null;
 var previousUrl = null;
@@ -335,9 +341,9 @@ var openSignInWindow = (url, name) => __async(void 0, null, function* () {
     windowObjectReference = window.open(url, name, strWindowFeatures);
   } else if (previousUrl !== url) {
     windowObjectReference = window.open(url, name, strWindowFeatures);
-    windowObjectReference.focus();
+    windowObjectReference == null ? void 0 : windowObjectReference.focus();
   } else {
-    windowObjectReference.focus();
+    windowObjectReference == null ? void 0 : windowObjectReference.focus();
   }
   window.addEventListener("message", (event) => receiveMessage(event), false);
   previousUrl = url;
@@ -433,6 +439,21 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Permanently deletes the current member's account.
+     * This action cannot be undone. The member will be logged out after deletion.
+     *
+     * @returns Promise resolving to deletion confirmation
+     *
+     * @example
+     * ```typescript
+     * // Confirm with user before calling
+     * if (confirm('Are you sure? This cannot be undone.')) {
+     *   await memberstack.deleteMember();
+     *   window.location.href = '/goodbye';
+     * }
+     * ```
+     */
     deleteMember() {
       return __async(this, null, function* () {
         const data = yield sendRequest({
@@ -597,6 +618,22 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Retrieves gated/secure content by its content ID.
+     * Use this to fetch content that requires specific plan access.
+     *
+     * @param params - Content parameters
+     * @param params.contentId - The ID of the secure content block to retrieve
+     * @returns Promise resolving to the secure content data
+     *
+     * @example
+     * ```typescript
+     * const { data: content } = await memberstack.getSecureContent({
+     *   contentId: 'cnt_abc123'
+     * });
+     * document.getElementById('premium-content').innerHTML = content.html;
+     * ```
+     */
     getSecureContent(params) {
       return __async(this, null, function* () {
         const data = yield sendRequest({
@@ -609,22 +646,52 @@ var initRequest = ({
         return data;
       });
     },
+    /**
+     * Signs up a new member using an OAuth provider (e.g., Google, Facebook).
+     * Opens a popup window for the OAuth flow. On success, the member is created and logged in.
+     *
+     * @param params - Signup parameters
+     * @param params.provider - The OAuth provider to use ('google', 'facebook', etc.)
+     * @param params.customFields - Optional custom field values to set during signup
+     * @param params.plans - Optional array of plan objects to assign on signup
+     * @param params.inviteToken - Optional team invite token
+     * @returns Promise resolving to the authenticated member data
+     *
+     * @example Sign up with Google
+     * ```typescript
+     * const { data } = await memberstack.signupWithProvider({
+     *   provider: 'google'
+     * });
+     * console.log('Signed up:', data.member.auth.email);
+     * ```
+     *
+     * @example Sign up with custom fields
+     * ```typescript
+     * await memberstack.signupWithProvider({
+     *   provider: 'google',
+     *   customFields: { role: 'developer' },
+     *   plans: [{ planId: 'pln_free' }]
+     * });
+     * ```
+     */
     signupWithProvider(params) {
       return __async(this, null, function* () {
         const customFields = encodeURIComponent(params.customFields ? JSON.stringify(params.customFields) : "{}");
         const plans = encodeURIComponent(params.plans ? JSON.stringify(params.plans) : "[]");
         const conversionData = getConversionData();
-        const queryParams = new URLSearchParams(__spreadProps(__spreadValues({
+        const queryParams = new URLSearchParams(__spreadProps(__spreadValues(__spreadProps(__spreadValues(__spreadValues({
           provider: params.provider,
           customFields,
           plans,
-          appId
+          appId: appId != null ? appId : ""
         }, publicKey && {
           publicKey
+        }), params.inviteToken && {
+          inviteToken: params.inviteToken
         }), {
           url: window.location.pathname,
-          origin: window.location.hostname,
-          sessionId: conversionData.sessionId,
+          origin: window.location.hostname
+        }), conversionData.sessionId && { sessionId: conversionData.sessionId }), {
           browser: conversionData.browser,
           os: conversionData.os,
           screenSize: conversionData.screenSize
@@ -632,12 +699,37 @@ var initRequest = ({
         return openSignInWindow(`${domain}/auth-provider/signup?${queryParams}`, "signup");
       });
     },
+    /**
+     * Logs in an existing member using an OAuth provider (e.g., Google, Facebook).
+     * Opens a popup window for the OAuth flow. Member must already have an account linked to this provider.
+     *
+     * @param params - Login parameters
+     * @param params.provider - The OAuth provider to use ('google', 'facebook', etc.)
+     * @param params.allowSignup - If true, creates a new account if one doesn't exist (default: false)
+     * @returns Promise resolving to the authenticated member data
+     *
+     * @example Log in with Google
+     * ```typescript
+     * const { data } = await memberstack.loginWithProvider({
+     *   provider: 'google'
+     * });
+     * console.log('Logged in:', data.member.auth.email);
+     * ```
+     *
+     * @example Allow signup if account doesn't exist
+     * ```typescript
+     * const { data } = await memberstack.loginWithProvider({
+     *   provider: 'google',
+     *   allowSignup: true
+     * });
+     * ```
+     */
     loginWithProvider(params) {
       return __async(this, null, function* () {
-        const allowSignup = encodeURIComponent(params.allowSignup === true ? true : false);
+        const allowSignup = encodeURIComponent(params.allowSignup === true ? "true" : "false");
         const queryParams = new URLSearchParams(__spreadProps(__spreadValues({
           provider: params.provider,
-          appId
+          appId: appId != null ? appId : ""
         }, publicKey && {
           publicKey
         }), {
@@ -647,20 +739,54 @@ var initRequest = ({
         return openSignInWindow(`${domain}/auth-provider/login?${queryParams}`, "login");
       });
     },
+    /**
+     * Connects an OAuth provider to the current member's account.
+     * Allows the member to use additional OAuth providers for login.
+     * Member must be logged in to use this method.
+     *
+     * @param params - Provider parameters
+     * @param params.provider - The OAuth provider to connect ('google', 'facebook', etc.)
+     * @returns Promise resolving to the connection result
+     *
+     * @example Connect Google to existing account
+     * ```typescript
+     * await memberstack.connectProvider({
+     *   provider: 'google'
+     * });
+     * // Member can now log in with either email/password or Google
+     * ```
+     */
     connectProvider(params) {
       return __async(this, null, function* () {
-        const queryParams = new URLSearchParams(__spreadProps(__spreadValues({
+        const memberToken = getMemberToken();
+        const queryParams = new URLSearchParams(__spreadProps(__spreadValues(__spreadValues({
           provider: params.provider,
-          appId
+          appId: appId != null ? appId : ""
         }, publicKey && {
           publicKey
-        }), {
-          member: getMemberToken(),
+        }), memberToken && { member: memberToken }), {
           origin: window.location.hostname
         }));
         return openSignInWindow(`${domain}/auth-provider/connect?${queryParams}`, "connect");
       });
     },
+    /**
+     * Disconnects an OAuth provider from the current member's account.
+     * After disconnecting, the member can no longer use this provider to log in.
+     * Member must be logged in and have another login method available.
+     *
+     * @param params - Provider parameters
+     * @param params.provider - The OAuth provider to disconnect ('google', 'facebook', etc.)
+     * @returns Promise resolving to the disconnection result
+     *
+     * @example Disconnect Google from account
+     * ```typescript
+     * await memberstack.disconnectProvider({
+     *   provider: 'google'
+     * });
+     * // Member must now use email/password or another connected provider
+     * ```
+     */
     disconnectProvider(params) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -679,8 +805,6 @@ var initRequest = ({
           method: "POST" /* POST */,
           url: `/app-member`,
           data: {
-            email: params.email,
-            password: params.password,
             data: {
               // @ts-ignore
               includeSSOText: window == null ? void 0 : window.ssoUI,
@@ -699,6 +823,19 @@ var initRequest = ({
         return data;
       });
     },
+    /**
+     * Retrieves your Memberstack app configuration.
+     * Returns app settings including authentication options, branding, and enabled features.
+     *
+     * @returns Promise resolving to the app configuration
+     *
+     * @example
+     * ```typescript
+     * const { data: app } = await memberstack.getApp();
+     * console.log('App name:', app.name);
+     * console.log('OAuth providers:', app.authProviders);
+     * ```
+     */
     getApp() {
       return __async(this, null, function* () {
         const queryParams = new URLSearchParams({
@@ -711,6 +848,29 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Authenticates a member using their email and password.
+     * On success, the member's session is automatically stored and they become the current user.
+     *
+     * @param params - Login credentials
+     * @param params.email - The member's email address
+     * @param params.password - The member's password
+     * @returns Promise resolving to the authenticated member data and tokens
+     * @throws When credentials are invalid or account doesn't exist
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const { data } = await memberstack.loginMemberEmailPassword({
+     *     email: 'user@example.com',
+     *     password: 'securePassword123'
+     *   });
+     *   console.log('Logged in:', data.member.auth.email);
+     * } catch (error) {
+     *   console.error('Login failed:', error.message);
+     * }
+     * ```
+     */
     loginMemberEmailPassword(params, options) {
       return __async(this, null, function* () {
         const data = yield sendRequest({
@@ -728,6 +888,26 @@ var initRequest = ({
         return data;
       });
     },
+    /**
+     * Sends a passwordless login code to an existing member's email.
+     * The member will receive a one-time code they can use to log in without a password.
+     *
+     * @param params - Email parameters
+     * @param params.email - The member's email address
+     * @returns Promise resolving to success confirmation
+     * @throws When the email is not associated with an existing member
+     *
+     * @example
+     * ```typescript
+     * // Step 1: Send the code
+     * await memberstack.sendMemberLoginPasswordlessEmail({
+     *   email: 'user@example.com'
+     * });
+     * // User receives email with code
+     *
+     * // Step 2: Complete login with the code (see loginMemberPasswordless)
+     * ```
+     */
     sendMemberLoginPasswordlessEmail(params, options) {
       return __async(this, null, function* () {
         return yield sendRequest({
@@ -739,6 +919,24 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Sends a passwordless signup code to a new member's email.
+     * Use this for registration flows where you don't want to collect passwords.
+     *
+     * @param params - Email parameters
+     * @param params.email - The new member's email address
+     * @returns Promise resolving to success confirmation
+     *
+     * @example
+     * ```typescript
+     * // Step 1: Send the signup code
+     * await memberstack.sendMemberSignupPasswordlessEmail({
+     *   email: 'newuser@example.com'
+     * });
+     *
+     * // Step 2: Complete signup with the code (see signupMemberPasswordless)
+     * ```
+     */
     sendMemberSignupPasswordlessEmail(params, options) {
       return __async(this, null, function* () {
         return yield sendRequest({
@@ -750,6 +948,26 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Completes passwordless login using the code sent via email.
+     * On success, the member is logged in and their session is stored.
+     *
+     * @param params - Login credentials
+     * @param params.email - The member's email address
+     * @param params.passwordlessToken - The one-time code from the email
+     * @returns Promise resolving to the authenticated member data and tokens
+     * @throws When the code is invalid or expired
+     *
+     * @example Complete passwordless login flow
+     * ```typescript
+     * // After user enters the code from their email
+     * const { data } = await memberstack.loginMemberPasswordless({
+     *   email: 'user@example.com',
+     *   passwordlessToken: '123456' // Code from email
+     * });
+     * console.log('Logged in:', data.member.auth.email);
+     * ```
+     */
     loginMemberPasswordless(params, options) {
       return __async(this, null, function* () {
         const data = yield sendRequest({
@@ -767,6 +985,23 @@ var initRequest = ({
         return data;
       });
     },
+    /**
+     * Retrieves details for a specific plan by ID.
+     * Returns plan information including name, description, and pricing.
+     *
+     * @param params - Plan parameters
+     * @param params.planId - The ID of the plan to retrieve
+     * @returns Promise resolving to the plan details
+     *
+     * @example
+     * ```typescript
+     * const { data: plan } = await memberstack.getPlan({
+     *   planId: 'pln_pro123'
+     * });
+     * console.log('Plan:', plan.name);
+     * console.log('Prices:', plan.prices);
+     * ```
+     */
     getPlan(params) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -775,6 +1010,36 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Retrieves all plans configured for your Memberstack app.
+     * Returns both free and paid plans with their pricing information.
+     *
+     * @returns Promise resolving to an array of plans
+     *
+     * @example List all plans
+     * ```typescript
+     * const { data: plans } = await memberstack.getPlans();
+     *
+     * plans.forEach(plan => {
+     *   console.log(plan.name, plan.id);
+     *   plan.prices?.forEach(price => {
+     *     console.log(`  ${price.name}: ${price.amount} ${price.currency}`);
+     *   });
+     * });
+     * ```
+     *
+     * @example Build a pricing page
+     * ```typescript
+     * const { data: plans } = await memberstack.getPlans();
+     *
+     * const pricingHtml = plans.map(plan => `
+     *   <div class="plan">
+     *     <h3>${plan.name}</h3>
+     *     <p>${plan.description}</p>
+     *   </div>
+     * `).join('');
+     * ```
+     */
     getPlans() {
       return __async(this, null, function* () {
         const { data } = yield sendRequest({
@@ -786,6 +1051,23 @@ var initRequest = ({
         };
       });
     },
+    /**
+     * Retrieves URL restriction groups configured for your app.
+     * These define which URLs require specific plans or authentication to access.
+     *
+     * @returns Promise resolving to an array of content access groups
+     *
+     * @example
+     * ```typescript
+     * const { data: groups } = await memberstack.getRestrictedUrlGroups();
+     *
+     * groups.forEach(group => {
+     *   console.log('Group:', group.name);
+     *   console.log('Required plans:', group.planIds);
+     *   console.log('URLs:', group.urls);
+     * });
+     * ```
+     */
     getRestrictedUrlGroups() {
       return __async(this, null, function* () {
         const { data } = yield sendRequest({
@@ -797,6 +1079,38 @@ var initRequest = ({
         };
       });
     },
+    /**
+     * Retrieves the currently authenticated member's data.
+     * Returns `null` if no user is logged in.
+     *
+     * @param options - Optional configuration
+     * @param options.useCache - If true, returns cached member data instead of fetching from server
+     * @returns Promise resolving to the current member's data, or null if not authenticated
+     *
+     * @example Check if user is logged in
+     * ```typescript
+     * const { data: member } = await memberstack.getCurrentMember();
+     *
+     * if (member) {
+     *   console.log('Logged in as:', member.auth.email);
+     *   console.log('Plans:', member.planConnections);
+     * } else {
+     *   console.log('Not logged in');
+     * }
+     * ```
+     *
+     * @example Access member properties
+     * ```typescript
+     * const { data: member } = await memberstack.getCurrentMember();
+     *
+     * if (member) {
+     *   const email = member.auth.email;
+     *   const isVerified = member.verified;
+     *   const customFields = member.customFields;
+     *   const hasPro = member.planConnections.some(p => p.planId === 'pln_pro');
+     * }
+     * ```
+     */
     getCurrentMember(options) {
       return __async(this, null, function* () {
         const memberToken = getMemberToken();
@@ -822,6 +1136,19 @@ var initRequest = ({
         }
       });
     },
+    /**
+     * Retrieves the current member's JSON data store.
+     * This is a flexible key-value store for storing arbitrary member data.
+     *
+     * @returns Promise resolving to the member's JSON data object
+     *
+     * @example
+     * ```typescript
+     * const { data: json } = await memberstack.getMemberJSON();
+     * console.log('Preferences:', json.preferences);
+     * console.log('Last visited:', json.lastVisitedPage);
+     * ```
+     */
     getMemberJSON(options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -831,6 +1158,35 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Updates the current member's JSON data store.
+     * You can store any JSON-serializable data. Updates are merged with existing data.
+     *
+     * @param params - JSON data to store
+     * @param params.json - Object containing the data to store
+     * @returns Promise resolving to the updated JSON data
+     *
+     * @example Store user preferences
+     * ```typescript
+     * await memberstack.updateMemberJSON({
+     *   json: {
+     *     preferences: { theme: 'dark', notifications: true },
+     *     lastVisitedPage: '/dashboard',
+     *     onboardingComplete: true
+     *   }
+     * });
+     * ```
+     *
+     * @example Store app-specific data
+     * ```typescript
+     * await memberstack.updateMemberJSON({
+     *   json: {
+     *     savedItems: ['item1', 'item2'],
+     *     progress: { level: 5, score: 1200 }
+     *   }
+     * });
+     * ```
+     */
     updateMemberJSON(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -843,6 +1199,22 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Adds a free plan to the current member.
+     * For paid plans, use `purchasePlansWithCheckout()` instead.
+     *
+     * @param params - Plan parameters
+     * @param params.planId - The ID of the free plan to add
+     * @returns Promise resolving to the updated member data with the new plan
+     *
+     * @example Add a free tier plan
+     * ```typescript
+     * const { data } = await memberstack.addPlan({
+     *   planId: 'pln_free_tier'
+     * });
+     * console.log('Plan added, redirect:', data.redirect);
+     * ```
+     */
     addPlan(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -855,11 +1227,54 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Initiates a Stripe checkout session for purchasing a paid plan.
+     * By default, redirects the user to Stripe's hosted checkout page.
+     *
+     * @param params - Checkout configuration
+     * @param params.priceId - The Memberstack price ID to purchase (e.g., 'prc_monthly_pro')
+     * @param params.successUrl - URL to redirect to after successful payment (relative or absolute)
+     * @param params.cancelUrl - URL to redirect to if user cancels checkout (relative or absolute)
+     * @param params.couponId - Optional Stripe coupon ID to apply
+     * @param params.autoRedirect - Set to `false` to get the checkout URL without redirecting
+     * @returns Promise resolving to checkout data (includes URL if autoRedirect is false)
+     *
+     * @example Start checkout for a plan
+     * ```typescript
+     * await memberstack.purchasePlansWithCheckout({
+     *   priceId: 'prc_monthly_pro',
+     *   successUrl: '/welcome',
+     *   cancelUrl: '/pricing'
+     * });
+     * // User is redirected to Stripe checkout
+     * ```
+     *
+     * @example Get checkout URL without redirecting
+     * ```typescript
+     * const { data } = await memberstack.purchasePlansWithCheckout({
+     *   priceId: 'prc_monthly_pro',
+     *   successUrl: '/welcome',
+     *   cancelUrl: '/pricing',
+     *   autoRedirect: false
+     * });
+     * console.log('Checkout URL:', data.url);
+     * ```
+     *
+     * @example Apply a coupon
+     * ```typescript
+     * await memberstack.purchasePlansWithCheckout({
+     *   priceId: 'prc_annual_pro',
+     *   couponId: 'SAVE20',
+     *   successUrl: '/welcome',
+     *   cancelUrl: '/pricing'
+     * });
+     * ```
+     */
     purchasePlansWithCheckout(params, options) {
       return __async(this, null, function* () {
-        function getRedirectURL(URL) {
+        function getRedirectURL(URL2) {
           let redirectUrl = window.location.href;
-          const urlParam = URL;
+          const urlParam = URL2;
           if (urlParam) {
             if (urlParam.indexOf("http://") === 0 || urlParam.indexOf("https://") === 0) {
               redirectUrl = urlParam;
@@ -870,7 +1285,7 @@ var initRequest = ({
           return redirectUrl;
         }
         const success_url = params.successUrl ? getRedirectURL(params.successUrl) : void 0;
-        const cancel_url = getRedirectURL(params.cancelUrl);
+        const cancel_url = params.cancelUrl ? getRedirectURL(params.cancelUrl) : window.location.href;
         const request = yield sendRequest({
           method: "POST" /* POST */,
           url: `/member/plans/create-checkout-session`,
@@ -892,14 +1307,42 @@ var initRequest = ({
           return request;
         }
         window.location.href = request.data.url;
+        return request;
       });
     },
-    // used for plan updates
+    /**
+     * Opens the Stripe Customer Portal for the current member.
+     * The portal allows members to manage their subscriptions, update payment methods, and view invoices.
+     * By default, redirects the user to the Stripe-hosted portal.
+     *
+     * @param params - Portal configuration
+     * @param params.returnUrl - URL to redirect to when member exits the portal (relative or absolute)
+     * @param params.priceIds - Optional array of price IDs to show for plan switching
+     * @param params.autoRedirect - Set to `false` to get the portal URL without redirecting
+     * @returns Promise resolving to portal data (includes URL if autoRedirect is false)
+     *
+     * @example Open customer portal
+     * ```typescript
+     * await memberstack.launchStripeCustomerPortal({
+     *   returnUrl: '/account'
+     * });
+     * // User is redirected to Stripe Customer Portal
+     * ```
+     *
+     * @example Get portal URL without redirecting
+     * ```typescript
+     * const { data } = await memberstack.launchStripeCustomerPortal({
+     *   returnUrl: '/account',
+     *   autoRedirect: false
+     * });
+     * console.log('Portal URL:', data.url);
+     * ```
+     */
     launchStripeCustomerPortal(params, options) {
       return __async(this, null, function* () {
-        function getRedirectURL(URL) {
+        function getRedirectURL(URL2) {
           let redirectUrl = window.location.href;
-          const urlParam = URL;
+          const urlParam = URL2;
           if (urlParam) {
             if (urlParam.indexOf("http://") === 0 || urlParam.indexOf("https://") === 0) {
               redirectUrl = urlParam;
@@ -927,8 +1370,25 @@ var initRequest = ({
           return request;
         }
         window.location.href = request.data.url;
+        return request;
       });
     },
+    /**
+     * Removes a plan from the current member.
+     * For paid plans, this will cancel the subscription.
+     *
+     * @param params - Plan parameters
+     * @param params.planId - The ID of the plan to remove
+     * @returns Promise resolving to the updated member data
+     *
+     * @example Remove a plan
+     * ```typescript
+     * await memberstack.removePlan({
+     *   planId: 'pln_premium'
+     * });
+     * // Plan removed/subscription cancelled
+     * ```
+     */
     removePlan(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -941,6 +1401,35 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Updates the current member's custom fields.
+     * Only updates the fields you specify; other fields remain unchanged.
+     *
+     * @param params - Update data
+     * @param params.customFields - Object containing custom field key-value pairs to update
+     * @returns Promise resolving to the updated member data
+     *
+     * @example Update custom fields
+     * ```typescript
+     * const { data: member } = await memberstack.updateMember({
+     *   customFields: {
+     *     firstName: 'Jane',
+     *     company: 'Acme Inc',
+     *     preferences: { theme: 'dark' }
+     *   }
+     * });
+     * console.log('Updated:', member.customFields);
+     * ```
+     *
+     * @example Update a single field
+     * ```typescript
+     * await memberstack.updateMember({
+     *   customFields: {
+     *     lastLoginPage: window.location.pathname
+     *   }
+     * });
+     * ```
+     */
     updateMember(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -951,6 +1440,33 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Updates the current member's authentication credentials (email and/or password).
+     * Requires the current password to verify the member's identity.
+     *
+     * @param params - Auth update parameters
+     * @param params.email - New email address (optional)
+     * @param params.oldPassword - Current password (required for password changes)
+     * @param params.newPassword - New password (optional)
+     * @returns Promise resolving to the updated member data
+     * @throws When the old password is incorrect
+     *
+     * @example Change email
+     * ```typescript
+     * await memberstack.updateMemberAuth({
+     *   email: 'newemail@example.com',
+     *   oldPassword: 'currentPassword'
+     * });
+     * ```
+     *
+     * @example Change password
+     * ```typescript
+     * await memberstack.updateMemberAuth({
+     *   oldPassword: 'currentPassword',
+     *   newPassword: 'newSecurePassword123'
+     * });
+     * ```
+     */
     updateMemberAuth(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -961,6 +1477,23 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Sets a password for a member who signed up via passwordless or OAuth.
+     * Use this when a member wants to add password-based login to their account.
+     *
+     * @param params - Password parameters
+     * @param params.password - The password to set
+     * @returns Promise resolving to the updated member data
+     *
+     * @example
+     * ```typescript
+     * // For members who signed up via Google OAuth or passwordless
+     * await memberstack.setPassword({
+     *   password: 'newSecurePassword123'
+     * });
+     * // Member can now log in with email/password
+     * ```
+     */
     setPassword(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1006,6 +1539,43 @@ var initRequest = ({
         return data;
       });
     },
+    /**
+     * Creates a new member account with email and password.
+     * On success, the member is automatically logged in and their session is stored.
+     *
+     * @param params - Signup details
+     * @param params.email - The new member's email address
+     * @param params.password - The new member's password (minimum 8 characters recommended)
+     * @param params.customFields - Optional custom field values defined in your Memberstack dashboard
+     * @param params.plans - Optional array of plan IDs to assign on signup (for free plans)
+     * @param params.metaData - Optional metadata to store with the member
+     * @param params.inviteToken - Optional team invite token for team signups
+     * @returns Promise resolving to the new member data and tokens
+     * @throws When email is already in use or validation fails
+     *
+     * @example Basic signup
+     * ```typescript
+     * const { data } = await memberstack.signupMemberEmailPassword({
+     *   email: 'newuser@example.com',
+     *   password: 'securePassword123'
+     * });
+     * console.log('Welcome!', data.member.id);
+     * ```
+     *
+     * @example Signup with custom fields and a free plan
+     * ```typescript
+     * const { data } = await memberstack.signupMemberEmailPassword({
+     *   email: 'newuser@example.com',
+     *   password: 'securePassword123',
+     *   customFields: {
+     *     firstName: 'Jane',
+     *     lastName: 'Doe',
+     *     company: 'Acme Inc'
+     *   },
+     *   plans: [{ planId: 'pln_free_tier' }]
+     * });
+     * ```
+     */
     signupMemberEmailPassword(params, options) {
       return __async(this, null, function* () {
         var _a2, _b, _c;
@@ -1087,20 +1657,52 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Uploads a new profile image for the current member.
+     * Accepts a File object (from an input element) or a Blob.
+     *
+     * @param params - Image parameters
+     * @param params.profileImage - The image file to upload
+     * @returns Promise resolving to the new profile image URL
+     *
+     * @example Upload from file input
+     * ```typescript
+     * const input = document.querySelector('input[type="file"]');
+     * const file = input.files[0];
+     *
+     * const { data } = await memberstack.updateMemberProfileImage({
+     *   profileImage: file
+     * });
+     * console.log('New image URL:', data.profileImage);
+     * ```
+     */
     updateMemberProfileImage(params) {
       return __async(this, null, function* () {
-        if (params.profileImage) {
-          const formData = new FormData();
-          formData.append("profileImage", params.profileImage);
-          return sendRequest({
-            method: "POST" /* POST */,
-            url: `/member/profile-image`,
-            data: formData,
-            contentType: "multipart/form-data"
-          });
+        if (!params.profileImage) {
+          throw new Error("profileImage is required");
         }
+        const formData = new FormData();
+        formData.append("profileImage", params.profileImage);
+        return sendRequest({
+          method: "POST" /* POST */,
+          url: `/member/profile-image`,
+          data: formData,
+          contentType: "multipart/form-data"
+        });
       });
     },
+    /**
+     * Sends a verification email to the current member.
+     * Use this when email verification is enabled in your Memberstack settings.
+     *
+     * @returns Promise resolving to success confirmation
+     *
+     * @example
+     * ```typescript
+     * await memberstack.sendMemberVerificationEmail();
+     * // Show message: "Verification email sent! Check your inbox."
+     * ```
+     */
     sendMemberVerificationEmail() {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1113,6 +1715,22 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Sends a password reset email to a member.
+     * The email contains a link with a token that can be used to reset their password.
+     *
+     * @param params - Email parameters
+     * @param params.email - The member's email address
+     * @returns Promise resolving to success confirmation
+     *
+     * @example
+     * ```typescript
+     * await memberstack.sendMemberResetPasswordEmail({
+     *   email: 'user@example.com'
+     * });
+     * // Show confirmation: "Check your email for reset instructions"
+     * ```
+     */
     sendMemberResetPasswordEmail(params) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1124,6 +1742,28 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Completes the password reset process using the token from the reset email.
+     * Typically called from a password reset page that receives the token via URL parameter.
+     *
+     * @param params - Reset parameters
+     * @param params.token - The reset token from the email link
+     * @param params.newPassword - The new password to set
+     * @returns Promise resolving to success confirmation
+     * @throws When the token is invalid or expired
+     *
+     * @example
+     * ```typescript
+     * // Get token from URL: /reset-password?token=abc123
+     * const token = new URLSearchParams(window.location.search).get('token');
+     *
+     * await memberstack.resetMemberPassword({
+     *   token,
+     *   newPassword: 'newSecurePassword123'
+     * });
+     * // Password updated, redirect to login
+     * ```
+     */
     resetMemberPassword(params) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1136,6 +1776,27 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Signs out the currently authenticated member.
+     * Clears the local session and invalidates the server-side session.
+     *
+     * @returns Promise resolving to logout confirmation (may include a redirect URL)
+     *
+     * @example
+     * ```typescript
+     * await memberstack.logout();
+     * // User is now logged out
+     * window.location.href = '/login';
+     * ```
+     *
+     * @example With redirect handling
+     * ```typescript
+     * const { data } = await memberstack.logout();
+     * if (data.redirect) {
+     *   window.location.href = data.redirect;
+     * }
+     * ```
+     */
     logout(options) {
       return __async(this, null, function* () {
         const data = yield sendRequest({
@@ -1148,6 +1809,20 @@ var initRequest = ({
       });
     },
     // Data Tables Methods
+    /**
+     * Retrieves all data tables configured for your app.
+     * Returns the list of tables and their schemas.
+     *
+     * @returns Promise resolving to an array of data tables
+     *
+     * @example
+     * ```typescript
+     * const { data: tables } = await memberstack.getDataTables();
+     * tables.forEach(table => {
+     *   console.log('Table:', table.name, table.key);
+     * });
+     * ```
+     */
     getDataTables(options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1157,6 +1832,21 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Retrieves a specific data table's schema and configuration.
+     *
+     * @param params - Table parameters
+     * @param params.table - The table key/identifier
+     * @returns Promise resolving to the table schema
+     *
+     * @example
+     * ```typescript
+     * const { data: table } = await memberstack.getDataTable({
+     *   table: 'posts'
+     * });
+     * console.log('Columns:', table.columns);
+     * ```
+     */
     getDataTable(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1167,6 +1857,30 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Retrieves records from a data table with optional filtering and pagination.
+     *
+     * @param params - Query parameters
+     * @param params.table - The table key/identifier
+     * @param params.limit - Maximum number of records to return
+     * @param params.after - Cursor for pagination (record ID to start after)
+     * @param params.sortBy - Field to sort by
+     * @param params.sortDirection - Sort direction ('asc' or 'desc')
+     * @param params.createdAfter - Filter records created after this date
+     * @param params.createdBefore - Filter records created before this date
+     * @returns Promise resolving to records array with pagination info
+     *
+     * @example List records with pagination
+     * ```typescript
+     * const { data } = await memberstack.getDataRecords({
+     *   table: 'posts',
+     *   limit: 10,
+     *   sortBy: 'createdAt',
+     *   sortDirection: 'desc'
+     * });
+     * console.log('Records:', data.records);
+     * ```
+     */
     getDataRecords(params, options) {
       return __async(this, null, function* () {
         var _a2;
@@ -1209,6 +1923,28 @@ var initRequest = ({
         return res;
       });
     },
+    /**
+     * Creates a new record in a data table.
+     *
+     * @param params - Record parameters
+     * @param params.table - The table key/identifier
+     * @param params.data - The record data as key-value pairs
+     * @param params.memberId - Optional member ID to associate with the record
+     * @returns Promise resolving to the created record
+     *
+     * @example Create a new post
+     * ```typescript
+     * const { data: record } = await memberstack.createDataRecord({
+     *   table: 'posts',
+     *   data: {
+     *     title: 'My First Post',
+     *     content: 'Hello world!',
+     *     published: true
+     *   }
+     * });
+     * console.log('Created record:', record.id);
+     * ```
+     */
     createDataRecord(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1222,6 +1958,23 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Retrieves a single record by ID from a data table.
+     *
+     * @param params - Record parameters
+     * @param params.table - The table key/identifier
+     * @param params.recordId - The ID of the record to retrieve
+     * @returns Promise resolving to the record data
+     *
+     * @example Get a specific post
+     * ```typescript
+     * const { data: record } = await memberstack.getDataRecord({
+     *   table: 'posts',
+     *   recordId: 'rec_abc123'
+     * });
+     * console.log('Post:', record.title);
+     * ```
+     */
     getDataRecord(params, options) {
       return __async(this, null, function* () {
         var _a2;
@@ -1244,6 +1997,25 @@ var initRequest = ({
         return res;
       });
     },
+    /**
+     * Updates an existing record in a data table.
+     *
+     * @param params - Update parameters
+     * @param params.recordId - The ID of the record to update
+     * @param params.data - The fields to update as key-value pairs
+     * @returns Promise resolving to the updated record
+     *
+     * @example Update a post
+     * ```typescript
+     * const { data: record } = await memberstack.updateDataRecord({
+     *   recordId: 'rec_abc123',
+     *   data: {
+     *     title: 'Updated Title',
+     *     published: false
+     *   }
+     * });
+     * ```
+     */
     updateDataRecord(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1256,6 +2028,20 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Deletes a record from a data table.
+     *
+     * @param params - Delete parameters
+     * @param params.recordId - The ID of the record to delete
+     * @returns Promise resolving to deletion confirmation
+     *
+     * @example Delete a post
+     * ```typescript
+     * await memberstack.deleteDataRecord({
+     *   recordId: 'rec_abc123'
+     * });
+     * ```
+     */
     deleteDataRecord(params, options) {
       return __async(this, null, function* () {
         return sendRequest({
@@ -1265,6 +2051,42 @@ var initRequest = ({
         });
       });
     },
+    /**
+     * Queries records from a data table with advanced filtering.
+     * Provides more control than getDataRecords for complex queries.
+     *
+     * @param params - Query parameters
+     * @param params.table - The table key/identifier
+     * @param params.query - Query object with where, orderBy, take, skip options
+     * @returns Promise resolving to matching records
+     *
+     * @example Query with filters
+     * ```typescript
+     * const { data } = await memberstack.queryDataRecords({
+     *   table: 'posts',
+     *   query: {
+     *     where: {
+     *       published: { equals: true },
+     *       category: { equals: 'tech' }
+     *     },
+     *     orderBy: { createdAt: 'desc' },
+     *     take: 10
+     *   }
+     * });
+     * ```
+     *
+     * @example Query with member filter
+     * ```typescript
+     * const { data } = await memberstack.queryDataRecords({
+     *   table: 'comments',
+     *   query: {
+     *     where: {
+     *       memberId: { equals: 'mem_xyz789' }
+     *     }
+     *   }
+     * });
+     * ```
+     */
     queryDataRecords(params, options) {
       return __async(this, null, function* () {
         return sendRequest({