@caffeinebounce/identity 0.12.1

package/dist/index.d.ts

@@ -0,0 +1,778 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ComponentType, ReactNode, CSSProperties } from 'react';
+import { SupabaseClient, AuthenticatorAssuranceLevels } from '@supabase/supabase-js';
+export { AuthCallbackConfig, AuthCallbackErrorSource, AuthCallbackFlow, AuthCallbackHook, AuthCallbackHookContext, AuthCallbackHookErrorMode, AuthCallbackLinkingErrorContext, AuthCallbackLinkingErrorMessageResolver, AuthCallbackLinkingFlowContext, AuthCallbackLinkingFlowDetector, AuthCallbackRedirectTarget, AuthCallbackSuccessRedirectResolver, createAuthCallbackHandler } from './server.js';
+export { DeviceFingerprint, GeolocationInfo, generateDeviceFingerprint, generateSecureToken, getClientIP, getGeolocationFromIP, hashString } from '@caffeinebounce/shared-utils';
+
+/**
+ * Type for the createClient function that apps must provide.
+ * This abstracts over browser vs server client creation.
+ *
+ * Using `any` for all generic parameters avoids version mismatches
+ * between packages with different Supabase client versions.
+ */
+type CreateClientFn = () => SupabaseClient<any, any, any, any, any>;
+/**
+ * Configuration for OAuth providers
+ */
+type OAuthProvider = "google" | "azure";
+/**
+ * Logo configuration for auth pages
+ */
+interface AuthLogo {
+    /** Logo image source (URL or path) */
+    src: string;
+    /** Alt text for the logo */
+    alt: string;
+    /** Logo width in pixels */
+    width?: number;
+    /** Logo height in pixels */
+    height?: number;
+}
+/**
+ * Common configuration for auth forms
+ */
+interface AuthFormConfig {
+    /** App name displayed in headings */
+    appName?: string;
+    /** Logo configuration */
+    logo?: AuthLogo;
+    /** URL to terms of service page */
+    termsUrl?: string;
+    /** URL to privacy policy page */
+    privacyUrl?: string;
+    /** Supabase client factory */
+    createClient: CreateClientFn;
+}
+/**
+ * Link configuration for auth pages
+ */
+interface AuthLinks {
+    /** Sign in page path */
+    signIn?: string;
+    /** Sign up page path */
+    signUp?: string;
+    /** Forgot password page path */
+    forgotPassword?: string;
+    /** Reset password page path */
+    resetPassword?: string;
+    /** Auth callback route for PKCE code exchange (e.g., /callback) */
+    callback?: string;
+    /** Home page path */
+    home?: string;
+    /** Default redirect after auth */
+    defaultRedirect?: string;
+}
+/**
+ * Default auth links
+ */
+declare const defaultAuthLinks: Required<AuthLinks>;
+
+/**
+ * Password reset event logging callbacks
+ */
+interface PasswordResetEventCallbacks {
+    onPasswordResetRequested?: (email: string) => void;
+}
+interface ForgotPasswordFormProps extends AuthFormConfig {
+    /** Navigation links configuration */
+    links?: AuthLinks;
+    /** Image component to use (e.g., Next.js Image) */
+    ImageComponent?: ComponentType<{
+        src: string;
+        alt: string;
+        width: number;
+        height: number;
+        className?: string;
+    }>;
+    /** Link component to use (e.g., Next.js Link) */
+    LinkComponent?: ComponentType<{
+        href: string;
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    /** Additional className for the form container */
+    className?: string;
+    /** Optional callbacks for logging password reset events */
+    onAuthEvent?: PasswordResetEventCallbacks;
+}
+/**
+ * ForgotPasswordForm - Password reset request form
+ */
+declare function ForgotPasswordForm({ createClient, logo, links, ImageComponent, LinkComponent, className, onAuthEvent, }: ForgotPasswordFormProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Password reset completion event logging callbacks
+ */
+interface ResetPasswordEventCallbacks {
+    onPasswordResetCompleted?: (userId: string, email: string) => void;
+    onPasswordResetFailed?: (email: string, reason: string) => void;
+}
+interface ResetPasswordFormProps extends AuthFormConfig {
+    /** MFA Challenge component to render when MFA is required */
+    MFAChallengeComponent?: ComponentType<{
+        onSuccess: () => void;
+        onCancel: () => void;
+    }>;
+    /** Navigation links configuration */
+    links?: AuthLinks;
+    /** Image component to use (e.g., Next.js Image) */
+    ImageComponent?: ComponentType<{
+        src: string;
+        alt: string;
+        width: number;
+        height: number;
+        className?: string;
+    }>;
+    /** Link component to use (e.g., Next.js Link) */
+    LinkComponent?: ComponentType<{
+        href: string;
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    /** Additional className for the form container */
+    className?: string;
+    /** Optional callbacks for logging password reset events */
+    onAuthEvent?: ResetPasswordEventCallbacks;
+}
+/**
+ * ResetPasswordForm - Set new password after reset link
+ */
+declare function ResetPasswordForm({ createClient, logo, MFAChallengeComponent, links, ImageComponent, LinkComponent, className, onAuthEvent, }: ResetPasswordFormProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Authentication event logging callbacks
+ */
+interface AuthEventCallbacks {
+    onSignInAttempt?: (email: string, provider?: string) => void;
+    onSignInSuccess?: (userId: string, email: string, mfaUsed?: boolean) => void;
+    onSignInFailure?: (email: string, reason: string) => void;
+    onMFARequired?: (userId: string, email: string) => void;
+}
+interface SigninFormProps extends AuthFormConfig {
+    /** MFA Challenge component to render when MFA is required */
+    MFAChallengeComponent?: ComponentType<{
+        redirectTo: string;
+        onSuccess: () => void;
+        onCancel: () => void;
+    }>;
+    /** Navigation links configuration */
+    links?: AuthLinks;
+    /** Image component to use (e.g., Next.js Image) */
+    ImageComponent?: ComponentType<{
+        src: string;
+        alt: string;
+        width: number;
+        height: number;
+        className?: string;
+    }>;
+    /** Link component to use (e.g., Next.js Link) */
+    LinkComponent?: ComponentType<{
+        href: string;
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    /** OAuth providers to show (default: ["azure"]) */
+    oauthProviders?: OAuthProvider[];
+    /** Show "Coming Soon" for Google OAuth */
+    googleComingSoon?: boolean;
+    /** Show "Coming Soon" for Microsoft OAuth */
+    azureComingSoon?: boolean;
+    /** When true, OAuth provider icons switch to monochrome (current text color) on hover */
+    oauthIconMonochromeOnHover?: boolean;
+    /** Additional className for the form container */
+    className?: string;
+    /** Optional callbacks for logging authentication events */
+    onAuthEvent?: AuthEventCallbacks;
+    /** Show hint about last used sign-in method. Default: true */
+    showLastSignInHint?: boolean;
+    /** Show the Home back-link on the auth form. Default: true */
+    showHomeLink?: boolean;
+    /** localStorage key for last sign-in data. Default: "last_signin" */
+    lastSignInStorageKey?: string;
+    /** Whether to show the logo inside the card. Default: true */
+    showLogo?: boolean;
+}
+/**
+ * SigninForm - Configurable sign-in form with email/password and OAuth support
+ *
+ * @example
+ * ```tsx
+ * <SigninForm
+ *   createClient={createClient}
+ *   logo={{ src: "/logo.png", alt: "My App" }}
+ *   appName="My App"
+ *   MFAChallengeComponent={MFAChallenge}
+ *   LinkComponent={Link}
+ *   ImageComponent={Image}
+ * />
+ * ```
+ */
+declare function SigninForm({ createClient, logo, appName, termsUrl, privacyUrl, MFAChallengeComponent, links, ImageComponent, LinkComponent, oauthProviders, googleComingSoon, azureComingSoon, oauthIconMonochromeOnHover, className, onAuthEvent, showLastSignInHint, showHomeLink, lastSignInStorageKey, showLogo, }: SigninFormProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Authentication event logging callbacks for sign-up
+ */
+interface SignupEventCallbacks {
+    onSignUpAttempt?: (email: string, provider?: string) => void;
+    onSignUpSuccess?: (userId: string, email: string) => void;
+    onSignUpFailure?: (email: string, reason: string) => void;
+    onEmailVerificationSent?: (email: string) => void;
+}
+/**
+ * Configuration for a consent checkbox (program updates, marketing, etc.)
+ */
+interface ConsentItem {
+    /** Unique identifier, used as the key in user metadata (e.g., "email_marketing") */
+    id: string;
+    /**
+     * Label content displayed next to the checkbox.
+     * Note: Do not include a required indicator (*) in the label text - the component
+     * will automatically append it when required: true.
+     */
+    label: React.ReactNode;
+    /** Optional description below the label (can include links) */
+    description?: React.ReactNode;
+    /** Whether this consent is required to submit the form */
+    required?: boolean;
+    /** Default checked state */
+    defaultChecked?: boolean;
+    /** Error message shown when required consent is not given */
+    errorMessage?: string;
+}
+interface SignupFormProps extends AuthFormConfig {
+    /** Navigation links configuration */
+    links?: AuthLinks;
+    /** Image component to use (e.g., Next.js Image) */
+    ImageComponent?: ComponentType<{
+        src: string;
+        alt: string;
+        width: number;
+        height: number;
+        className?: string;
+    }>;
+    /** Link component to use (e.g., Next.js Link) */
+    LinkComponent?: ComponentType<{
+        href: string;
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    /** OAuth providers to show (default: ["azure"]) */
+    oauthProviders?: OAuthProvider[];
+    /** Show "Coming Soon" for Google OAuth */
+    googleComingSoon?: boolean;
+    /** Show "Coming Soon" for Microsoft OAuth */
+    azureComingSoon?: boolean;
+    /** When true, OAuth provider icons switch to monochrome (current text color) on hover */
+    oauthIconMonochromeOnHover?: boolean;
+    /** Additional className for the form container */
+    className?: string;
+    /** Optional callbacks for logging authentication events */
+    onAuthEvent?: SignupEventCallbacks;
+    /** Array of consent items to display (e.g., marketing opt-in, terms acceptance) */
+    consentItems?: ConsentItem[];
+    /** Position of consent checkboxes relative to submit button (default: "above") */
+    consentPosition?: "above" | "below";
+    /** Size of consent text - compact uses smaller text (default: "default") */
+    consentSize?: "default" | "compact";
+    /** Show the Home back-link on the auth form. Default: true */
+    showHomeLink?: boolean;
+    /** Whether to show the logo inside the card. Default: true */
+    showLogo?: boolean;
+}
+/**
+ * SignupForm - Configurable sign-up form with email/password and OAuth support
+ */
+declare function SignupForm({ createClient, logo, appName, termsUrl, privacyUrl, links, ImageComponent, LinkComponent, oauthProviders, googleComingSoon, azureComingSoon, oauthIconMonochromeOnHover, className, onAuthEvent, consentItems, consentPosition, consentSize, showHomeLink, showLogo, }: SignupFormProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * MFA event logging callbacks
+ */
+interface MFAEventCallbacks {
+    onMFASuccess?: (userId: string, email: string) => void;
+    onMFAFailure?: (userId: string, email: string, reason: string) => void;
+}
+interface MFAChallengeProps {
+    /** Supabase client factory */
+    createClient: CreateClientFn;
+    /** Callback when MFA verification succeeds */
+    onSuccess?: () => void;
+    /** Callback when user cancels MFA */
+    onCancel?: () => void;
+    /** Callback when user clicks recovery link */
+    onRecovery?: () => void;
+    /** Where to redirect after successful MFA (if onSuccess not provided) */
+    redirectTo?: string;
+    /** Sign-in URL to redirect to on cancel (if onCancel not provided) */
+    signInUrl?: string;
+    /** Recovery URL to redirect to on recovery (if onRecovery not provided) */
+    recoveryUrl?: string;
+    /** Optional callbacks for logging MFA events */
+    onAuthEvent?: MFAEventCallbacks;
+}
+/**
+ * MFAChallenge - Supabase MFA verification component
+ *
+ * Wraps the generic @caffeinebounce/ui MFAChallenge component with Supabase MFA API.
+ *
+ * @example
+ * ```tsx
+ * <MFAChallenge
+ *   createClient={createClient}
+ *   redirectTo="/dashboard"
+ *   onCancel={() => router.push("/signin")}
+ * />
+ * ```
+ */
+declare function MFAChallenge({ createClient, onSuccess, onCancel, onRecovery, redirectTo, signInUrl, recoveryUrl, onAuthEvent, }: MFAChallengeProps): react_jsx_runtime.JSX.Element;
+
+interface MFAConfirmDialogProps {
+    /** Function to create a Supabase client */
+    createClient: CreateClientFn;
+    /** Whether the dialog is open */
+    open: boolean;
+    /** Callback when dialog open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Callback when MFA verification succeeds */
+    onConfirm: () => void | Promise<void>;
+    /** The factor ID to verify against */
+    factorId: string;
+    /** Factor type - determines if we need to send a code first */
+    factorType: "totp" | "phone";
+    /** Optional title override */
+    title?: string;
+    /** Optional description override */
+    description?: string;
+    /** Optional confirm button text */
+    confirmText?: string;
+    /** Whether the confirm action is in progress */
+    confirmLoading?: boolean;
+}
+/**
+ * MFAConfirmDialog - Reusable dialog for confirming sensitive actions with MFA
+ *
+ * Use this component anywhere you need to verify the user's identity before
+ * performing a sensitive action (e.g., removing MFA, changing email, etc.)
+ *
+ * @example
+ * ```tsx
+ * <MFAConfirmDialog
+ *   createClient={createClient}
+ *   open={showConfirm}
+ *   onOpenChange={setShowConfirm}
+ *   onConfirm={handleDelete}
+ *   factorId={factor.id}
+ *   factorType="totp"
+ *   confirmText="Remove"
+ * />
+ * ```
+ */
+declare function MFAConfirmDialog({ createClient, open, onOpenChange, onConfirm, factorId, factorType, title, description, confirmText, confirmLoading, }: MFAConfirmDialogProps): react_jsx_runtime.JSX.Element;
+
+interface MFAContextType {
+    currentLevel: AuthenticatorAssuranceLevels | null;
+    nextLevel: AuthenticatorAssuranceLevels | null;
+    needsMFA: boolean;
+    loading: boolean;
+    refreshAAL: () => Promise<void>;
+}
+declare function useMFA(): MFAContextType;
+interface MFAProviderProps {
+    /** Supabase client factory */
+    createClient: CreateClientFn;
+    /** Children to render */
+    children: ReactNode;
+}
+/**
+ * MFAProvider - Context provider for MFA state
+ *
+ * Tracks the current MFA assurance level and provides hooks for checking MFA status.
+ *
+ * @example
+ * ```tsx
+ * <MFAProvider createClient={createClient}>
+ *   <App />
+ * </MFAProvider>
+ * ```
+ */
+declare function MFAProvider({ createClient, children }: MFAProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * useRequireMFA - Hook to check if MFA verification is required
+ *
+ * @example
+ * ```tsx
+ * const { needsMFA, loading, isVerified } = useRequireMFA();
+ *
+ * if (loading) return <Loading />;
+ * if (needsMFA) return <MFAChallenge />;
+ * if (!isVerified) return <AccessDenied />;
+ * ```
+ */
+declare function useRequireMFA(): {
+    needsMFA: boolean;
+    loading: boolean;
+    isVerified: boolean;
+};
+
+interface MFARecoveryProps {
+    /** Supabase client factory */
+    createClient: CreateClientFn;
+    /** Callback when recovery succeeds */
+    onSuccess?: () => void;
+    /** Callback when user wants to go back to MFA challenge */
+    onBack?: () => void;
+    /** Callback when user cancels recovery */
+    onCancel?: () => void;
+    /** Where to redirect after successful recovery (if onSuccess not provided) */
+    redirectTo?: string;
+    /** MFA challenge URL to redirect back to (if onBack not provided) */
+    mfaChallengeUrl?: string;
+    /** Sign-in URL to redirect to on cancel (if onCancel not provided) */
+    signInUrl?: string;
+}
+/**
+ * MFARecovery - Supabase MFA recovery component
+ *
+ * Wraps the generic @caffeinebounce/ui MFARecovery component with Supabase recovery API.
+ *
+ * @example
+ * ```tsx
+ * <MFARecovery
+ *   createClient={createClient}
+ *   redirectTo="/profile#security"
+ *   onBack={() => router.push("/mfa-challenge")}
+ * />
+ * ```
+ */
+declare function MFARecovery({ createClient, onSuccess, onBack, onCancel, redirectTo, mfaChallengeUrl, signInUrl, }: MFARecoveryProps): react_jsx_runtime.JSX.Element;
+
+interface TwoFactorSectionProps {
+    /** Function to create a Supabase client */
+    createClient: CreateClientFn;
+}
+declare function TwoFactorSection({ createClient }: TwoFactorSectionProps): react_jsx_runtime.JSX.Element;
+
+interface DeleteAccountSectionProps {
+    /** Function to create a Supabase client */
+    createClient: CreateClientFn;
+    /** User's email address for confirmation */
+    email: string;
+    /** Optional retention days before permanent deletion (default: 30) */
+    retentionDays?: number;
+}
+/**
+ * DeleteAccountSection - Allow users to soft-delete their account
+ *
+ * This component provides a secure flow for account deletion with:
+ * - MFA verification if user has MFA enabled
+ * - Typed confirmation (user must type their email or "DELETE")
+ * - Clear explanation of consequences
+ *
+ * @example
+ * ```tsx
+ * <DeleteAccountSection
+ *   createClient={createClient}
+ *   email={user.email}
+ *   retentionDays={30}
+ * />
+ * ```
+ */
+declare function DeleteAccountSection({ createClient, email, retentionDays, }: DeleteAccountSectionProps): react_jsx_runtime.JSX.Element;
+
+interface EmailSectionProps {
+    /** Function to create a Supabase client */
+    createClient: CreateClientFn;
+    /** User ID (reserved for future use) */
+    userId: string;
+    /** Current email address */
+    email: string;
+    /** Whether the email is verified */
+    isVerified: boolean;
+    /** Callback when email is changed */
+    onEmailChanged: (newEmail: string) => void;
+}
+declare function EmailSection({ createClient, userId: _userId, email, isVerified, onEmailChanged, }: EmailSectionProps): react_jsx_runtime.JSX.Element;
+
+interface LinkedAccountsSectionProps {
+    /** Function to create a Supabase client */
+    createClient: CreateClientFn;
+    /** Callback when user needs to set a password before disconnecting */
+    onSetPasswordClick?: () => void;
+    /** Redirect URL after OAuth callback */
+    callbackRedirectUrl?: string;
+    /** External error message (e.g., from OAuth callback) */
+    linkError?: string | null;
+}
+declare function LinkedAccountsSection({ createClient, onSetPasswordClick, callbackRedirectUrl, linkError: externalLinkError, }: LinkedAccountsSectionProps): react_jsx_runtime.JSX.Element;
+
+interface PasswordSectionProps {
+    /** Function to create a Supabase client */
+    createClient: CreateClientFn;
+    /** External control of dialog open state */
+    externalOpen?: boolean;
+    /** Callback when external open state changes */
+    onExternalOpenChange?: (open: boolean) => void;
+}
+declare function PasswordSection({ createClient, externalOpen, onExternalOpenChange, }: PasswordSectionProps): react_jsx_runtime.JSX.Element;
+
+interface PhoneSectionProps {
+    /** Function to create a Supabase client */
+    createClient: CreateClientFn;
+    /** User ID (reserved for future use) */
+    userId: string;
+    /** Current phone number */
+    phone: string;
+    /** Whether the phone is verified */
+    isVerified: boolean;
+    /** Callback when phone is changed */
+    onPhoneChanged: (newPhone: string) => void;
+    /** API endpoint for phone verification (default: /api/phone/verify) */
+    verifyEndpoint?: string;
+}
+declare function PhoneSection({ createClient, userId: _userId, phone, isVerified, onPhoneChanged, verifyEndpoint, }: PhoneSectionProps): react_jsx_runtime.JSX.Element;
+
+interface RecoverySectionProps {
+    /** Function to create a Supabase client */
+    createClient: CreateClientFn;
+}
+/**
+ * RecoverySection - Manage account recovery options
+ *
+ * Displays recovery methods like backup codes. Only shows backup codes
+ * if the user has MFA enabled.
+ */
+declare function RecoverySection({ createClient }: RecoverySectionProps): react_jsx_runtime.JSX.Element;
+
+interface AuthFormLayoutProps {
+    /** Form content (inside the card) */
+    children: ReactNode;
+    /** Footer content (outside the card, e.g., terms/privacy) */
+    footer?: ReactNode;
+    /** Home link URL */
+    homeUrl?: string;
+    /** Whether to show the home link */
+    showHomeLink?: boolean;
+    /** Link component to use (e.g., Next.js Link) */
+    LinkComponent?: ComponentType<{
+        href: string;
+        className?: string;
+        children: ReactNode;
+    }>;
+    /** Additional className for the card */
+    className?: string;
+}
+/**
+ * AuthFormLayout - Shared layout for auth form cards
+ *
+ * Provides consistent positioning, home link, and card styling for all auth forms.
+ */
+declare function AuthFormLayout({ children, footer, homeUrl, showHomeLink, LinkComponent, className, }: AuthFormLayoutProps): react_jsx_runtime.JSX.Element;
+
+interface AuthHeaderProps {
+    /** Logo configuration */
+    logo?: {
+        src: string;
+        alt: string;
+        width?: number;
+        height?: number;
+    };
+    /** Title text (e.g., "Sign in to {appName}") */
+    title: string;
+    /** Image component to use (e.g., Next.js Image) */
+    ImageComponent?: ComponentType<{
+        src: string;
+        alt: string;
+        width: number;
+        height: number;
+        className?: string;
+    }>;
+    /** Whether to show the logo inside the card. Default: true */
+    showLogo?: boolean;
+    /** Additional className */
+    className?: string;
+}
+/**
+ * AuthHeader - Shared header component for auth forms with logo and title
+ */
+declare function AuthHeader({ logo, title, ImageComponent, className, }: AuthHeaderProps): react_jsx_runtime.JSX.Element;
+
+type AuthPageVariant = "gradient" | "plain" | "ripple" | "rolling";
+interface AuthColorScheme {
+    /** Page background color */
+    background?: string;
+    /** Secondary background for gradients */
+    backgroundAlt?: string;
+    /** Card background color */
+    cardBg?: string;
+    /** Card border color */
+    cardBorder?: string;
+    /** Primary accent color */
+    accent?: string;
+    /** Text on accent backgrounds */
+    accentForeground?: string;
+    /** Primary text color */
+    text?: string;
+    /** Muted text color */
+    textMuted?: string;
+}
+interface AuthPageLayoutProps {
+    /** Page content */
+    children: ReactNode;
+    /** Background variant. Default: "gradient" */
+    variant?: AuthPageVariant;
+    /** Color scheme override (merged with variant defaults) */
+    colorScheme?: Partial<AuthColorScheme>;
+    /** Logo to display above the sign-in card (external positioning) */
+    externalLogo?: {
+        src: string;
+        alt: string;
+    };
+    /** Size preset for the external logo. Default: "md" */
+    externalLogoSize?: "sm" | "md" | "lg" | "xl";
+    /** Image component for external logo rendering */
+    ExternalLogoImageComponent?: ComponentType<{
+        src: string;
+        alt: string;
+        width: number;
+        height: number;
+        className?: string;
+        style?: CSSProperties;
+    }>;
+    /** Logo element for rolling variant background watermark */
+    rollingLogo?: ReactNode;
+    /**
+     * Show the interactive ripple effect.
+     * @deprecated Use variant="ripple" instead.
+     */
+    showRippleEffect?: boolean;
+}
+/**
+ * AuthPageLayout - Full-page layout for auth pages with configurable background variant.
+ *
+ * @example Basic usage (gradient, backward compat)
+ * ```tsx
+ * <AuthPageLayout showRippleEffect>
+ *   <SigninForm ... />
+ * </AuthPageLayout>
+ * ```
+ *
+ * @example Rolling variant
+ * ```tsx
+ * <AuthPageLayout variant="rolling" rollingLogo={<MyLogo />}>
+ *   <SigninForm ... />
+ * </AuthPageLayout>
+ * ```
+ */
+declare function AuthPageLayout({ children, variant: variantProp, colorScheme, showRippleEffect, externalLogo, externalLogoSize, ExternalLogoImageComponent, rollingLogo, }: AuthPageLayoutProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Supported sign-in methods.
+ * NOTE: Keep in sync with OAuthProvider type in types.ts.
+ * Add new providers here only after they are fully wired into the sign-in flow.
+ */
+type SignInMethod = "email" | "google" | "azure";
+/** Stored last sign-in data */
+interface LastSignInData {
+    /** The authentication method used */
+    method: SignInMethod;
+    /** The email address (will be masked when displayed) */
+    email: string;
+    /** ISO timestamp of when this sign-in occurred */
+    timestamp: string;
+}
+/** Options for the useLastSignIn hook */
+interface UseLastSignInOptions {
+    /** localStorage key for storing data. Default: "last_signin" */
+    storageKey?: string;
+}
+/**
+ * Mask an email address for privacy display.
+ * Shows first character, asterisks, and domain.
+ * @example "user@example.com" -> "u***@example.com"
+ */
+declare function maskEmail(email: string): string;
+/**
+ * Hook to manage last sign-in method tracking.
+ *
+ * Stores and retrieves the user's last successful sign-in method
+ * in localStorage to help them remember how they signed up.
+ *
+ * @example
+ * ```tsx
+ * function SigninPage() {
+ *   const { lastSignIn, recordSignIn, clearLastSignIn } = useLastSignIn();
+ *
+ *   // Show hint if available
+ *   if (lastSignIn) {
+ *     return <LastSignInHint {...lastSignIn} onClear={clearLastSignIn} />;
+ *   }
+ *
+ *   // Record on successful sign-in
+ *   const handleSuccess = (method, email) => {
+ *     recordSignIn(method, email);
+ *   };
+ * }
+ * ```
+ */
+declare function useLastSignIn(options?: UseLastSignInOptions): {
+    /** The last sign-in data, or null if none stored */
+    lastSignIn: LastSignInData | null;
+    /** Whether the hook has finished loading from localStorage */
+    isLoaded: boolean;
+    /** Record a new sign-in */
+    recordSignIn: (method: SignInMethod, email: string) => void;
+    /** Clear stored sign-in data */
+    clearLastSignIn: () => void;
+    /** Mark an OAuth method as pending before redirecting to the provider */
+    markPendingOAuthSignIn: (method: Exclude<SignInMethod, "email">) => void;
+    /** Complete pending OAuth sign-in recording (call after OAuth callback) */
+    completePendingOAuthSignIn: (email: string) => void;
+};
+
+interface LastSignInHintProps {
+    /** The sign-in method that was last used */
+    method: SignInMethod;
+    /** The email address associated with the sign-in */
+    email: string;
+    /** Whether to mask the email for privacy. Default: true */
+    maskEmailAddress?: boolean;
+    /** Called when user clicks "Not you?" to clear the hint */
+    onClear?: () => void;
+    /** Additional className for the container */
+    className?: string;
+}
+/**
+ * LastSignInHint - Displays a helpful hint about the user's last sign-in method.
+ *
+ * Shows a subtle banner reminding users which authentication method they
+ * previously used, helping avoid confusion between email/password and OAuth.
+ *
+ * @example
+ * ```tsx
+ * <LastSignInHint
+ *   method="google"
+ *   email="user@example.com"
+ *   onClear={() => clearLastSignIn()}
+ * />
+ * ```
+ */
+declare function LastSignInHint({ method, email, maskEmailAddress, onClear, className, }: LastSignInHintProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * OAuth provider icons - Google and Microsoft
+ * These are inline SVGs for reliable rendering without external dependencies
+ */
+interface IconProps {
+    className?: string;
+    monochrome?: boolean;
+}
+declare function GoogleIcon({ className, monochrome }: IconProps): react_jsx_runtime.JSX.Element;
+declare function MicrosoftIcon({ className, monochrome }: IconProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Generate cryptographically secure recovery codes
+ * Uses crypto.getRandomValues() for secure random number generation
+ */
+declare function generateRecoveryCodes(count?: number): string[];
+
+export { type AuthFormConfig, AuthFormLayout, type AuthFormLayoutProps, AuthHeader, type AuthHeaderProps, type AuthLinks, type AuthLogo, AuthPageLayout, type AuthPageLayoutProps, type ConsentItem, type CreateClientFn, DeleteAccountSection, type DeleteAccountSectionProps, EmailSection, type EmailSectionProps, ForgotPasswordForm, type ForgotPasswordFormProps, GoogleIcon, type LastSignInData, LastSignInHint, type LastSignInHintProps, LinkedAccountsSection, type LinkedAccountsSectionProps, MFAChallenge, type MFAChallengeProps, MFAConfirmDialog, type MFAConfirmDialogProps, MFAProvider, type MFAProviderProps, MFARecovery, type MFARecoveryProps, MicrosoftIcon, type OAuthProvider, PasswordSection, type PasswordSectionProps, PhoneSection, type PhoneSectionProps, RecoverySection, type RecoverySectionProps, ResetPasswordForm, type ResetPasswordFormProps, type SignInMethod, SigninForm, type SigninFormProps, SignupForm, type SignupFormProps, TwoFactorSection, type TwoFactorSectionProps, type UseLastSignInOptions, defaultAuthLinks, generateRecoveryCodes, maskEmail, useLastSignIn, useMFA, useRequireMFA };