@memberstack/dom 2.0.0 → 2.0.2-beta.0

package/lib/methods/requests/index.d.mts

@@ -4,6 +4,10 @@ import '../../types/utils/payloads.mjs';
 
 interface MemberstackOptions {
     token?: BearerToken;
+    /** @internal Used by Webflow package to include content groups in response */
+    includeContentGroups?: boolean;
+    /** @internal Used by Webflow package to identify requests from Webflow integration */
+    isWebflow?: boolean;
 }
 interface GetCurrentMemberParams {
     useCache?: Boolean;
@@ -21,71 +25,887 @@ declare const initRequest: ({ publicKey, appId, token, domain, }: ClientConfig)
     _Event(params: {
         data: any;
     }): Promise<void>;
+    /**
+     * 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(): Promise<DeleteMemberPayload>;
     postIsTyping(params: {
         channelKey: string;
     }): Promise<void>;
-    getChannelInfo(params?: {
+    getChannelInfo(params: {
         channelKey: string;
     }): Promise<any>;
-    subscribeToChannel(params?: {
+    subscribeToChannel(params: {
         channelKey: string;
         action: "NONE" | "THREADS_ONLY";
     }): Promise<void>;
-    getPosts(params?: GetPostsParams): Promise<GetPostsPayload>;
-    getThreads(params?: GetThreadsParams): Promise<GetThreadsPayload>;
-    createPost(params?: CreatePostParams): Promise<CreatePostPayload>;
-    updatePost(params?: UpdatePostParams): Promise<UpdatePostPayload>;
-    postVote(params?: PostVoteParams): Promise<void>;
-    deletePost(params?: DeletePostParams): Promise<void>;
-    createThread(params?: CreateThreadParams): Promise<CreateThreadPayload>;
-    updateThread(params?: UpdateThreadParams): Promise<UpdateThreadPayload>;
-    threadVote(params?: ThreadVoteParams): Promise<void>;
-    deleteThread(params?: DeleteThreadParams): Promise<void>;
-    getSecureContent(params?: GetSecureContentParams): Promise<GetSecureContentPayload>;
-    signupWithProvider(params?: SignupWithProviderParams): Promise<unknown>;
-    loginWithProvider(params?: LoginWithProviderParams): Promise<unknown>;
-    connectProvider(params?: LoginWithProviderParams): Promise<ConnectProviderPayload>;
+    getPosts(params: GetPostsParams): Promise<GetPostsPayload>;
+    getThreads(params: GetThreadsParams): Promise<GetThreadsPayload>;
+    createPost(params: CreatePostParams): Promise<CreatePostPayload>;
+    updatePost(params: UpdatePostParams): Promise<UpdatePostPayload>;
+    postVote(params: PostVoteParams): Promise<void>;
+    deletePost(params: DeletePostParams): Promise<void>;
+    createThread(params: CreateThreadParams): Promise<CreateThreadPayload>;
+    updateThread(params: UpdateThreadParams): Promise<UpdateThreadPayload>;
+    threadVote(params: ThreadVoteParams): Promise<void>;
+    deleteThread(params: DeleteThreadParams): Promise<void>;
+    /**
+     * 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: GetSecureContentParams): Promise<GetSecureContentPayload>;
+    /**
+     * 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: SignupWithProviderParams): Promise<unknown>;
+    /**
+     * 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: LoginWithProviderParams): Promise<unknown>;
+    /**
+     * 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: LoginWithProviderParams): Promise<ConnectProviderPayload>;
+    /**
+     * 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: LoginWithProviderParams): Promise<ConnectProviderPayload>;
-    getAppAndMember(params?: any): Promise<GetAppAndMemberPayload>;
+    getAppAndMember(params?: {
+        trackPageView?: boolean;
+    }): Promise<GetAppAndMemberPayload>;
+    /**
+     * 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(): Promise<AppPayload>;
-    loginMemberEmailPassword(params: LoginMemberEmailPasswordParams, options?: any): Promise<LoginMemberEmailPasswordPayload>;
-    sendMemberLoginPasswordlessEmail(params: SendMemberLoginPasswordlessEmailParams, options?: any): Promise<SendMemberLoginPasswordlessEmailPayload>;
-    sendMemberSignupPasswordlessEmail(params: SendMemberLoginPasswordlessEmailParams, options?: any): Promise<SendMemberLoginPasswordlessEmailPayload>;
-    loginMemberPasswordless(params: LoginMemberPasswordlessParams, options?: any): Promise<LoginMemberEmailPasswordPayload>;
+    /**
+     * 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: LoginMemberEmailPasswordParams, options?: MemberstackOptions): Promise<LoginMemberEmailPasswordPayload>;
+    /**
+     * 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: SendMemberLoginPasswordlessEmailParams, options?: MemberstackOptions): Promise<SendMemberLoginPasswordlessEmailPayload>;
+    /**
+     * 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: SendMemberLoginPasswordlessEmailParams, options?: MemberstackOptions): Promise<SendMemberLoginPasswordlessEmailPayload>;
+    /**
+     * 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: LoginMemberPasswordlessParams, options?: MemberstackOptions): Promise<LoginMemberEmailPasswordPayload>;
+    /**
+     * 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: GetPlanParams): Promise<GetPlanPayload>;
+    /**
+     * 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(): Promise<GetPlansPayload>;
+    /**
+     * 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(): Promise<GetRestrictedUrlGroupsPayload>;
+    /**
+     * 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?: GetCurrentMemberParams): Promise<GetCurrentMemberPayload>;
+    /**
+     * 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?: MemberstackOptions): Promise<GetMemberJSONPayload>;
+    /**
+     * 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: UpdateMemberJSONParams, options?: MemberstackOptions): Promise<GetMemberJSONPayload>;
+    /**
+     * 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: AddPlanParams, options?: MemberstackOptions): Promise<AddPlanPayload>;
+    /**
+     * 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: PurchasePlansWithCheckoutParams, options?: MemberstackOptions): Promise<PurchasePlansWithCheckoutPayload>;
+    /**
+     * 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: LaunchStripeCustomerPortalParams, options?: MemberstackOptions): Promise<LaunchStripeCustomerPortalPayload>;
+    /**
+     * 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: RemovePlanParams, options?: MemberstackOptions): Promise<RemovePlanPayload>;
+    /**
+     * 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: UpdateMemberParams, options?: MemberstackOptions): Promise<UpdateMemberPayload>;
+    /**
+     * 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: UpdateMemberAuthParams, options?: MemberstackOptions): Promise<UpdateMemberAuthPayload>;
+    /**
+     * 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: SetPasswordParams, options?: MemberstackOptions): Promise<SetPasswordPayload>;
     signupMemberPasswordless(params: Omit<SignupMemberEmailPasswordParams, "password"> & {
         passwordlessToken: string;
-    }, options?: any): Promise<SignupMemberEmailPasswordPayload>;
-    signupMemberEmailPassword(params: SignupMemberEmailPasswordParams, options?: any): Promise<SignupMemberEmailPasswordPayload>;
+    }, options?: MemberstackOptions): Promise<SignupMemberEmailPasswordPayload>;
+    /**
+     * 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: SignupMemberEmailPasswordParams, options?: MemberstackOptions): Promise<SignupMemberEmailPasswordPayload>;
     joinTeam(params: JoinTeamParams, options?: MemberstackOptions): Promise<void>;
     getTeam(params: GetTeamParams, options?: MemberstackOptions): Promise<void>;
     removeMemberFromTeam(params: RemoveMemberFromTeamParams, options?: MemberstackOptions): Promise<void>;
     generateInviteToken(params: GenerateInviteTokenParams, options?: MemberstackOptions): Promise<void>;
+    /**
+     * 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: UpdateMemberProfileImageParams): Promise<UpdateMemberProfileImagePayload>;
+    /**
+     * 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(): Promise<SendMemberVerificationEmailPayload>;
+    /**
+     * 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: SendMemberResetPasswordEmailParams): Promise<SendMemberResetPasswordEmailPayload>;
+    /**
+     * 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: ResetMemberPasswordParams): Promise<ResetMemberPassworPayload>;
+    /**
+     * 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?: MemberstackOptions): Promise<LogoutMemberPayload>;
+    /**
+     * 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?: MemberstackOptions): Promise<GetDataTablesPayload>;
+    /**
+     * 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: GetDataTableParams, options?: MemberstackOptions): Promise<GetDataTablePayload>;
+    /**
+     * 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: GetDataRecordsParams, options?: MemberstackOptions): Promise<GetDataRecordsPayload>;
+    /**
+     * 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: CreateDataRecordParams, options?: MemberstackOptions): Promise<CreateDataRecordPayload>;
+    /**
+     * 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: GetDataRecordParams, options?: MemberstackOptions): Promise<GetDataRecordPayload>;
+    /**
+     * 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: UpdateDataRecordParams, options?: MemberstackOptions): Promise<UpdateDataRecordPayload>;
+    /**
+     * 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: DeleteDataRecordParams, options?: MemberstackOptions): Promise<DeleteDataRecordPayload>;
+    /**
+     * 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: QueryDataRecordsParams, options?: MemberstackOptions): Promise<QueryDataRecordsPayload>;
 };