@openfort/react 0.0.12 → 0.0.13

package/build/assets/browsers.d.ts

@@ -1,5 +1,5 @@
 /**
- * TODO: Move hex colors into css variables for p3 support
+ * TODO: Move hex colours into CSS variables for P3 support.
  */
 declare const _default: {
     Chrome: import("react/jsx-runtime").JSX.Element;

package/build/assets/logos.d.ts

@@ -89,6 +89,7 @@ export declare const providersLogos: {
     twitter: import("react/jsx-runtime").JSX.Element;
     facebook: import("react/jsx-runtime").JSX.Element;
     discord: import("react/jsx-runtime").JSX.Element;
+    apple: import("react/jsx-runtime").JSX.Element;
 };
 declare const _default: {
     Mock: ({ ...props }: {

package/build/components/Openfort/OpenfortProvider.d.ts

@@ -13,19 +13,32 @@ type OpenfortProviderProps = {
     thirdPartyAuth?: ThirdPartyAuthConfiguration;
 } & useConnectCallbackProps;
 /**
- * OpenfortProvider component provides context and configuration for Openfort.
- * It must be used within a WagmiProvider.
+ * Provides Openfort configuration and context to descendant components.
  *
- * @param {React.ReactNode} children - The child components to be wrapped by the provider.
- * @param {string} [theme='auto'] - The theme to be used, default is 'auto'.
- * @param {string} [mode='auto'] - The mode to be used, default is 'auto'.
- * @param {CustomTheme} [customTheme] - Custom theme configuration.
- * @param {ConnectUIOptions} [options] - Additional configuration options.
- * @param {Function} [onConnect] - Callback function to be called on connect.
- * @param {Function} [onDisconnect] - Callback function to be called on disconnect.
- * @param {boolean} [debugMode=false] - Enable or disable debug mode, default is false.
- * @param {OpenfortOptions} [openfortOptions] - Options for Openfort integration.
- * @throws Will throw an error if used outside of a WagmiProvider or if nested usages are detected.
+ * The provider must be rendered within a {@link WagmiContext} and should only be mounted once
+ * to avoid conflicting global state. See {@link OpenfortProviderProps} for the supported options.
+ *
+ * @param props - Provider configuration including callbacks, UI options and the wrapped children.
+ * @returns A React element that sets up the Openfort context.
+ * @throws If the component is rendered outside of a Wagmi provider or mounted multiple times.
+ *
+ * @example
+ * ```tsx
+ * import { WagmiConfig, createConfig } from 'wagmi';
+ * import { OpenfortProvider } from '@openfort/openfort-react';
+ *
+ * const config = createConfig({ YOU_WAGMI_CONFIG_HERE });
+ *
+ * export function App() {
+ *   return (
+ *     <WagmiConfig config={config}>
+ *       <OpenfortProvider publishableKey={process.env.NEXT_PUBLIC_PUBLISHABLE_KEY!}>
+ *         <YourApp />
+ *       </OpenfortProvider>
+ *     </WagmiConfig>
+ *   );
+ * }
+ * ```
  */
 export declare const OpenfortProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, overrides, thirdPartyAuth, }: OpenfortProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;
 export {};

package/build/components/Openfort/context.d.ts

@@ -35,6 +35,8 @@ export type ContextValue = {
     walletConfig?: OpenfortWalletConfig;
     overrides?: SDKOverrides;
     thirdPartyAuth?: ThirdPartyAuthConfiguration;
+    emailInput: string;
+    setEmailInput: React.Dispatch<React.SetStateAction<string>>;
 } & useConnectCallbackProps;
 export declare const Openfortcontext: React.Context<ContextValue | null>;
 export {};

package/build/components/Openfort/types.d.ts

@@ -8,7 +8,6 @@ export declare const routes: {
     readonly LOADING: "loading";
     readonly RECOVER: "recover";
     readonly EMAIL_LOGIN: "emailLogin";
-    readonly EMAIL_SIGNUP: "emailSignup";
     readonly FORGOT_PASSWORD: "forgotPassword";
     readonly EMAIL_VERIFICATION: "emailVerification";
     readonly LINK_EMAIL: "linkEmail";
@@ -26,6 +25,7 @@ export declare enum UIAuthProvider {
     TWITTER = "twitter",
     FACEBOOK = "facebook",
     DISCORD = "discord",
+    APPLE = "apple",
     EMAIL = "email",
     WALLET = "wallet",
     GUEST = "guest"
@@ -33,33 +33,29 @@ export declare enum UIAuthProvider {
 export declare const socialProviders: UIAuthProvider[];
 type PolicyConfig = string | Record<number, string>;
 type CommonWalletConfig = {
-    /** Publishable key for the Shield API */
+    /** Publishable key for the Shield API. */
     shieldPublishableKey: string;
-    /** Policy ID (pol_...) for the embedded signer */
+    /** Policy ID (pol_...) for the embedded signer. */
     ethereumProviderPolicyId?: PolicyConfig;
     accountType?: AccountTypeEnum;
     debug?: boolean;
 };
 type EncryptionSession = {
-    /** Function to retrieve an encryption session using a session ID */
+    /** Function to retrieve an encryption session using a session ID. */
     getEncryptionSession?: (accessToken: string) => Promise<string>;
     createEncryptedSessionEndpoint?: never;
 } | {
-    /** API endpoint for creating an encrypted session */
+    /** API endpoint for creating an encrypted session. */
     getEncryptionSession?: never;
     createEncryptedSessionEndpoint?: string;
 };
 /**
- * Configuration for automatic recovery.
- * - An encryption session is required.
+ * Configuration for wallet recovery behaviour.
  *
- * Configuration for password-based recovery.
- * - An encryption session, OR
- * - A `shieldEncryptionKey` without an encryption session.
- *
- * Encryption session can be created using either:
- * - `createEncryptedSessionEndpoint` as a string, OR
- * - `getEncryptionSession.` as a function that returns a promise.
+ * @remarks
+ * Automatic recovery requires an encryption session, which may be supplied via
+ * the `createEncryptedSessionEndpoint` endpoint or the `getEncryptionSession` callback.
+ * Password-based and passkey-based recovery methods do not require encryption sessions.
  */
 export type OpenfortWalletConfig = CommonWalletConfig & EncryptionSession;
 export type OpenfortUIOptions = {
@@ -85,17 +81,20 @@ export type ConnectUIOptions = {
     hideTooltips?: boolean;
     hideRecentBadge?: boolean;
     walletConnectCTA?: 'link' | 'modal' | 'both';
+    /** Avoids layout shift when the Openfort modal is open by adding padding to the body. */
     avoidLayoutShift?: boolean;
+    /** Automatically embeds the Google font of the current theme. Does not work with custom themes. */
     embedGoogleFonts?: boolean;
     truncateLongENSAddress?: boolean;
     walletConnectName?: string;
     reducedMotion?: boolean;
     disclaimer?: ReactNode | string;
-    /** Buffer Polyfill, needed for bundlers that don't provide Node polyfills (e.g CRA, Vite, etc.) */
+    /** Buffer polyfill, needed for bundlers that do not provide Node polyfills (e.g. CRA, Vite, etc.). */
     bufferPolyfill?: boolean;
     customAvatar?: React.FC<CustomAvatarProps>;
     initialChainId?: number;
     enforceSupportedChains?: boolean;
+    /** Blur intensity applied to the background when the modal is open. */
     overlayBlur?: number;
     walletRecovery?: WalletRecoveryOptions;
 } & Partial<OpenfortUIOptions>;
@@ -114,19 +113,24 @@ export type OpenfortUIOptionsExtended = {
     hideNoWalletCTA?: boolean;
     hideRecentBadge?: boolean;
     walletConnectCTA?: 'link' | 'modal' | 'both';
+    /** Avoids layout shift when the Openfort modal is open by adding padding to the body. */
     avoidLayoutShift?: boolean;
+    /** Automatically embeds the Google font of the current theme. Does not work with custom themes. */
     embedGoogleFonts?: boolean;
     truncateLongENSAddress?: boolean;
     walletConnectName?: string;
     reducedMotion?: boolean;
     disclaimer?: ReactNode | string;
+    /** Buffer polyfill, needed for bundlers that do not provide Node polyfills (e.g. CRA, Vite, etc.). */
     bufferPolyfill?: boolean;
     customAvatar?: React.FC<CustomAvatarProps>;
     initialChainId?: number;
     enforceSupportedChains?: boolean;
     ethereumOnboardingUrl?: string;
     walletOnboardingUrl?: string;
+    /** Disable redirect to the SIWE page after a wallet is connected. */
     disableSiweRedirect?: boolean;
+    /** Blur intensity applied to the background when the modal is open. */
     overlayBlur?: number;
     walletRecovery: WalletRecoveryOptionsExtended;
 } & OpenfortUIOptions;

package/build/components/Pages/EmailLogin/styles.d.ts

@@ -0,0 +1 @@
+export declare const FooterContainer: import("styled-components").StyledComponent<"span", any, {}, never>;

package/build/components/Pages/Providers/styles.d.ts

@@ -1,3 +1,5 @@
+export declare const ProviderInputInner: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const EmailInnerButton: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLButtonElement, import("framer-motion").HTMLMotionProps<"button">>, any, {}, never>;
 export declare const ProvidersButton: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const ProviderLabel: import("styled-components").StyledComponent<"span", any, {}, never>;
 export declare const ProviderIcon: import("styled-components").StyledComponent<"div", any, {}, never>;

package/build/components/PasswordStrength/password-utility.d.ts

@@ -1,52 +1,86 @@
 /**
- * Password Utilities Module
- * Provides functions for password strength calculation, passphrase generation,
- * and password validation.
+ * Password utility helpers for strength calculation and validation.
+ *
+ * Provides functions for password strength calculation, passphrase generation, and password validation.
  */
 export declare const MEDIUM_SCORE_THRESHOLD = 0.5;
 export declare const STRONG_SCORE_THRESHOLD = 0.75;
 export declare const VERY_STRONG_SCORE_THRESHOLD = 0.9;
-/** Password strength levels */
+/**
+ * Password strength levels.
+ */
 export type PasswordStrengthLabel = 'Weak' | 'Medium' | 'Strong' | 'Very Strong';
-/** Password summary information */
+/**
+ * Password summary information.
+ */
 export interface PasswordSummary {
     value: number;
     label: PasswordStrengthLabel;
 }
 /**
  * Gets a list of invalid characters in the provided text.
- * Replaces spaces with 'SPACE' for visibility.
  *
- * @param text - The text to check for invalid characters
- * @returns Array of unique invalid characters
+ * Replaces spaces with `SPACE` for visibility.
+ *
+ * @param text - The text to check for invalid characters.
+ * @returns Array of unique invalid characters.
+ *
+ * @example
+ * ```ts
+ * const invalid = getInvalidCharacters('Pa$$ word');
+ * // invalid === ['$', 'SPACE']
+ * ```
  */
 export declare function getInvalidCharacters(text?: string): string[];
 /**
  * Converts a numeric password strength score to a human-readable label.
  *
- * @param score - The strength score (0-1)
- * @returns The corresponding strength label
+ * @param score - The strength score (0-1).
+ * @returns The corresponding strength label.
+ *
+ * @example
+ * ```ts
+ * const label = getPasswordStrengthLabel(0.8);
+ * // label === 'Strong'
+ * ```
  */
 export declare function getPasswordStrengthLabel(score: number): PasswordStrengthLabel;
 /**
  * Calculates the diversity score of a password based on character types used.
+ *
  * Considers lowercase, uppercase, digits, and special characters.
  *
- * @param password - The password to analyze
- * @returns A score between 0 and 1 representing character diversity
+ * @param password - The password to analyse.
+ * @returns A score between 0 and 1 representing character diversity.
+ *
+ * @example
+ * ```ts
+ * const diversity = calculatePasswordDiversityScore('Password123!');
+ * ```
  */
 export declare function calculatePasswordDiversityScore(password: string): number;
 /**
  * Calculates the overall password strength combining diversity and entropy.
  *
- * @param password - The password to analyze
- * @returns A strength score between 0 and 1
+ * @param password - The password to analyse.
+ * @returns A strength score between 0 and 1.
+ *
+ * @example
+ * ```ts
+ * const strength = getPasswordStrength('Password123!');
+ * ```
  */
 export declare function getPasswordStrength(password?: string): number;
 /**
  * Gets a comprehensive summary of password strength.
  *
- * @param password - The password to analyze
- * @returns An object containing the strength value and label
+ * @param password - The password to analyse.
+ * @returns An object containing the strength value and label.
+ *
+ * @example
+ * ```ts
+ * const summary = getPasswordSummary('Password123!');
+ * // summary === { value: 0.74, label: 'Strong' }
+ * ```
  */
 export declare function getPasswordSummary(password?: string): PasswordSummary;

package/build/components/contexts/web3/index.d.ts

@@ -1,5 +1,12 @@
 /**
- * This provider is responsible for handling reusable web3 logic across the app.
+ * Provides reusable Web3 state and helpers to descendant components.
+ *
+ * @example
+ * ```tsx
+ * <Web3ContextProvider>
+ *   <WalletSelector />
+ * </Web3ContextProvider>
+ * ```
  */
 import { Address, Chain } from 'viem';
 type Web3Context = {
@@ -20,5 +27,15 @@ export declare const Web3ContextProvider: ({ enabled, children, }: {
     enabled?: boolean;
     children: React.ReactNode;
 }) => import("react/jsx-runtime").JSX.Element;
+/**
+ * React hook to access the {@link Web3Context} values.
+ *
+ * @returns Shared Web3 utilities exposed by the provider.
+ *
+ * @example
+ * ```ts
+ * const { account } = useWeb3();
+ * ```
+ */
 export declare const useWeb3: () => Web3Context;
 export {};

package/build/constants/openfort.d.ts

@@ -1,2 +1 @@
 export declare const embeddedWalletId = "xyz.openfort";
-export declare const emailToVerifyLocalStorageKey = "openfort:email-to-verify";

package/build/defaultTransports.d.ts

@@ -1,15 +1,38 @@
 /**
- * TODO: Automate transports based on configured chains
- *
- * Developers using this causes loss of granular control over a dapps transports,
- * but for simple use cases, it's nice to have and saves a lot of boilerplate.
+ * Helpers for constructing default Wagmi transports for supported chains.
  *
+ * These utilities favour convenience over granular control, making them suitable for
+ * straightforward integrations where automatically configuring transports is preferable to
+ * repeating boilerplate in every application.
  */
 import { type CreateConfigParameters } from '@wagmi/core';
+/**
+ * Options for {@link getDefaultTransports}.
+ */
 type GetDefaultTransportsProps = {
     chains?: CreateConfigParameters['chains'];
     alchemyId?: string;
     infuraId?: string;
 };
+/**
+ * Creates a map of Wagmi transports for the provided chains.
+ *
+ * @param props - Configuration for the generated transports.
+ * @param props.chains - Chains that require transports. Defaults to popular EVM chains.
+ * @param props.alchemyId - Alchemy API key used to prioritise Alchemy transports when available.
+ * @param props.infuraId - Infura API key used to prioritise Infura transports when available.
+ * @returns A record mapping chain identifiers to their fallback transport configuration.
+ *
+ * @example
+ * ```ts
+ * import { createConfig } from 'wagmi';
+ * import { getDefaultTransports } from '@openfort/openfort-react';
+ *
+ * const config = createConfig({
+ *   chains: [mainnet],
+ *   transports: getDefaultTransports({ alchemyId: process.env.ALCHEMY_ID ?? '' }),
+ * });
+ * ```
+ */
 export declare const getDefaultTransports: ({ chains, alchemyId, infuraId, }: GetDefaultTransportsProps) => CreateConfigParameters["transports"];
 export {};

package/build/hooks/openfort/auth/useAuthCallback.d.ts

@@ -11,6 +11,69 @@ type CallbackResult = (StoreCredentialsResult & {
 type UseAuthCallbackOptions = {
     enabled?: boolean;
 } & OpenfortHookOptions<CallbackResult> & CreateWalletPostAuthOptions;
+/**
+ * Hook for handling authentication callbacks from OAuth providers and email verification
+ *
+ * This hook automatically processes authentication callbacks when the page loads with
+ * authentication parameters in the URL. It handles both OAuth provider callbacks
+ * (with access tokens) and email verification callbacks (with state tokens).
+ * The hook extracts parameters from the URL and automatically calls the appropriate
+ * authentication methods, then cleans up the URL parameters.
+ *
+ * @param options - Optional configuration with callback functions and authentication options
+ * @returns Current callback processing state and extracted information
+ *
+ * @example
+ * ```tsx
+ * const authCallback = useAuthCallback({
+ *   enabled: true,
+ *   onSuccess: (result) => {
+ *     if (result.type === 'storeCredentials') {
+ *       console.log('OAuth callback processed:', result.user);
+ *     } else if (result.type === 'verifyEmail') {
+ *       console.log('Email verified:', result.email);
+ *     }
+ *   },
+ *   onError: (error) => console.error('Callback processing failed:', error),
+ *   recoverWalletAutomatically: true,
+ * });
+ *
+ * // Check callback processing state
+ * if (authCallback.isLoading) {
+ *   console.log('Processing authentication callback...');
+ * } else if (authCallback.isError) {
+ *   console.error('Callback error:', authCallback.error);
+ * } else if (authCallback.isSuccess) {
+ *   console.log('Callback processed successfully');
+ * }
+ *
+ * // Access extracted information
+ * if (authCallback.provider) {
+ *   console.log('Authentication provider:', authCallback.provider);
+ * }
+ *
+ * if (authCallback.email) {
+ *   console.log('Email from callback:', authCallback.email);
+ * }
+ *
+ * // Manually trigger verification (if needed)
+ * const handleManualVerification = async () => {
+ *   await authCallback.verifyEmail({
+ *     email: 'user@example.com',
+ *     state: 'verification-token',
+ *   });
+ * };
+ *
+ * // Manually store credentials (if needed)
+ * const handleManualStore = async () => {
+ *   await authCallback.storeCredentials({
+ *     player: 'player-id',
+ *     accessToken: 'access-token',
+ *     refreshToken: 'refresh-token',
+ *   });
+ * };
+ * ```
+ */
 export declare const useAuthCallback: ({ enabled, ...hookOptions }?: UseAuthCallbackOptions) => {
     email: string | null;
     provider: UIAuthProvider | null;

package/build/hooks/openfort/auth/useConnectToWalletPostAuth.d.ts

@@ -1,16 +1,38 @@
 import { UserWallet } from "../useWallets";
+/**
+ * Options that control the behaviour of {@link useConnectToWalletPostAuth} when attempting to
+ * recover or create an embedded wallet after authentication.
+ */
 export type CreateWalletPostAuthOptions = {
     /**
-     * @default true
-     * It will log out the user if there is an error while trying to create a wallet (automatic recovery).
+     * Whether the user should be signed out if automatic wallet creation fails.
+     *
+     * @defaultValue true
      */
     logoutOnError?: boolean;
     /**
-     * @default true
-     * It will automatically try to recover the first wallet with automatic recovery.
+     * Whether the hook should automatically attempt to recover an existing wallet that
+     * supports automatic recovery.
+     *
+     * @defaultValue true
      */
     recoverWalletAutomatically?: boolean;
 };
+/**
+ * React hook that attempts to recover or create an embedded wallet once a user has authenticated.
+ *
+ * @returns Helpers that execute the post-authentication wallet connection flow.
+ *
+ * @example
+ * ```ts
+ * const { tryUseWallet } = useConnectToWalletPostAuth();
+ *
+ * const result = await tryUseWallet({ recoverWalletAutomatically: false });
+ * if (!result.wallet) {
+ *   console.warn('No embedded wallet available after authentication');
+ * }
+ * ```
+ */
 export declare const useConnectToWalletPostAuth: () => {
     tryUseWallet: ({ logoutOnError: signOutOnError, recoverWalletAutomatically }: CreateWalletPostAuthOptions) => Promise<{
         wallet?: UserWallet;

package/build/hooks/openfort/auth/useEmailAuth.d.ts

@@ -44,6 +44,77 @@ export type EmailVerificationResult = {
 export type UseEmailHookOptions = {
     emailVerificationRedirectTo?: string;
 } & OpenfortHookOptions<EmailAuthResult | EmailVerificationResult> & CreateWalletPostAuthOptions;
+/**
+ * Hook for email-based authentication operations
+ *
+ * This hook manages email authentication flows including sign-in, sign-up, password reset,
+ * email verification, and email linking. It handles both password and passwordless authentication
+ * and automatically manages wallet connection after successful authentication.
+ *
+ * @param hookOptions - Optional configuration with callback functions and authentication options
+ * @returns Current authentication state with email auth actions
+ *
+ * @example
+ * ```tsx
+ * const emailAuth = useEmailAuth({
+ *   onSignInEmailSuccess: (result) => console.log('Signed in:', result.user),
+ *   onSignInEmailError: (error) => console.error('Sign-in failed:', error),
+ *   emailVerificationRedirectTo: 'https://yourapp.com/verify',
+ *   recoverWalletAutomatically: true,
+ * });
+ *
+ * // Sign up with email and password
+ * await emailAuth.signUpEmail({
+ *   email: 'user@example.com',
+ *   password: 'securePassword123',
+ *   name: 'John Doe',
+ * });
+ *
+ * // Sign in with email and password
+ * await emailAuth.signInEmail({
+ *   email: 'user@example.com',
+ *   password: 'securePassword123',
+ * });
+ *
+ * // Request password reset
+ * await emailAuth.requestResetPassword({
+ *   email: 'user@example.com',
+ * });
+ *
+ * // Reset password with state token
+ * await emailAuth.resetPassword({
+ *   email: 'user@example.com',
+ *   password: 'newPassword123',
+ *   state: 'reset-token-from-email',
+ * });
+ *
+ * // Verify email with state token
+ * await emailAuth.verifyEmail({
+ *   email: 'user@example.com',
+ *   state: 'verification-token-from-email',
+ * });
+ *
+ * // Link email to existing authenticated account
+ * await emailAuth.linkEmail({
+ *   email: 'secondary@example.com',
+ *   password: 'password123',
+ * });
+ *
+ * // Check authentication state
+ * if (emailAuth.isLoading) {
+ *   console.log('Processing authentication...');
+ * } else if (emailAuth.isError) {
+ *   console.error('Authentication error:', emailAuth.error);
+ * } else if (emailAuth.isSuccess) {
+ *   console.log('Authentication successful');
+ * }
+ *
+ * // Handle email verification requirement
+ * if (emailAuth.requiresEmailVerification) {
+ *   console.log('Please check your email to verify your account');
+ * }
+ * ```
+ */
 export declare const useEmailAuth: (hookOptions?: UseEmailHookOptions) => {
     requiresEmailVerification: boolean;
     isAwaitingInput: boolean;

package/build/hooks/openfort/auth/useGuestAuth.d.ts

@@ -8,6 +8,65 @@ export type GuestHookResult = {
     wallet?: UserWallet;
 };
 export type GuestHookOptions = OpenfortHookOptions<GuestHookResult> & CreateWalletPostAuthOptions;
+/**
+ * Hook for guest authentication operations
+ *
+ * This hook manages guest user authentication, allowing users to create temporary
+ * accounts without providing email or other credentials. Guest authentication provides
+ * a quick way for users to get started with the application before committing to
+ * full registration. After authentication, it automatically handles wallet connection.
+ *
+ * @param hookOptions - Optional configuration with callback functions and authentication options
+ * @returns Current guest authentication state and actions
+ *
+ * @example
+ * ```tsx
+ * const guestAuth = useGuestAuth({
+ *   onSignUpGuestSuccess: (result) => console.log('Guest user created:', result.user),
+ *   onSignUpGuestError: (error) => console.error('Guest signup failed:', error),
+ *   recoverWalletAutomatically: true,
+ *   logoutOnError: false,
+ * });
+ *
+ * // Sign up as guest user
+ * const handleGuestSignup = async () => {
+ *   try {
+ *     const result = await guestAuth.signUpGuest();
+ *     if (result.user) {
+ *       console.log('Guest user created:', result.user.id);
+ *       console.log('User wallet:', result.wallet);
+ *     }
+ *   } catch (error) {
+ *     console.error('Guest signup failed:', error);
+ *   }
+ * };
+ *
+ * // Check authentication state
+ * if (guestAuth.isLoading) {
+ *   console.log('Creating guest account...');
+ * } else if (guestAuth.isError) {
+ *   console.error('Guest auth error:', guestAuth.error);
+ * } else if (guestAuth.isSuccess) {
+ *   console.log('Guest authentication successful');
+ * }
+ *
+ * // Example usage in component
+ * return (
+ *   <div>
+ *     <button
+ *       onClick={handleGuestSignup}
+ *       disabled={guestAuth.isLoading}
+ *     >
+ *       {guestAuth.isLoading ? 'Creating Guest Account...' : 'Continue as Guest'}
+ *     </button>
+ *
+ *     {guestAuth.isError && (
+ *       <p>Error: {guestAuth.error?.message}</p>
+ *     )}
+ *   </div>
+ * );
+ * ```
+ */
 export declare const useGuestAuth: (hookOptions?: GuestHookOptions) => {
     isLoading: boolean;
     isError: boolean;