mailsentry-auth 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1492 @@
+import { FormInstance } from 'antd/es/form';
+import { Store } from 'rc-field-form/lib/interface';
+import { FormItemProps } from 'antd';
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { NextRequest, NextResponse } from 'next/server';
+import { InputProps } from 'antd/es/input';
+import { PasswordProps } from 'antd/es/input/Password';
+import * as immer from 'immer';
+import * as zustand from 'zustand';
+
+/**
+ * Authentication Stepper Enums
+ *
+ * This file contains all enum definitions related to authentication flow steps
+ * and stepper functionality. These enums provide type safety and better
+ * maintainability compared to string literals.
+ */
+/**
+ * Enum for authentication flow steps in the stepper UI component
+ */
+declare enum AuthFlowStep {
+    EMAIL = "email",
+    PASSWORD = "password",
+    VERIFICATION = "verification"
+}
+/**
+ * Enum for next action after email check
+ */
+declare enum NextAction {
+    LOGIN = "login",
+    SIGNUP = "signup",
+    LOGIN_VERIFICATION = "login-verification"
+}
+
+interface BaseResponse {
+    statusCode: number;
+    message: string;
+    _metadata: {
+        languages: string[];
+        timestamp: number;
+        timezone: string;
+        requestId: string;
+        path: string;
+        version: string;
+        repoVersion: string;
+    };
+}
+interface EmailExistResponse {
+    next_action: NextAction;
+}
+interface LoginRequest {
+    email: string;
+    password: string;
+}
+interface LoginData {
+    roleType: string;
+    accessToken: string;
+    refreshToken: string;
+    isVerifiedEmail: boolean;
+    profile: UserProfile;
+    tokenInfo: {
+        domain: string;
+    };
+}
+interface LoginResponse extends BaseResponse {
+    data: LoginData;
+}
+interface VerifyEmailRequest {
+    email: string;
+    code: string;
+}
+interface VerifyEmailResponse extends BaseResponse {
+    data: {
+        isVerified: boolean;
+    };
+}
+interface UserProfile {
+    user: {
+        _id: string;
+        firstName: string;
+        lastName: string;
+        email: string;
+        role: {
+            _id: string;
+            name: string;
+            isActive: boolean;
+            type: string;
+            permissions: string[];
+            createdAt: string;
+            updatedAt: string;
+        };
+        password: string;
+        passwordExpired: string;
+        passwordCreated: string;
+        passwordAttempt: number;
+        signUpDate: string;
+        signUpFrom: string;
+        salt: string;
+        isActive: boolean;
+        isEmailVerified: boolean;
+        inactivePermanent: boolean;
+        blocked: boolean;
+        createdAt: string;
+        updatedAt: string;
+        whiteListProject: string;
+    };
+    credits: Array<{
+        _id: string;
+        userId: string;
+        planId: string;
+        amount: number;
+        type: string;
+        inUse: boolean;
+        isDeleted: boolean;
+        sharedWith: string | null;
+        isExpired: boolean;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    teams: Array<{
+        _id: string;
+        userId: string;
+        teamId: string;
+        creditIsInUse: boolean;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+    project: {
+        _id: string;
+        name: string;
+        origin: string;
+        secretKey: string;
+        __v: number;
+    };
+}
+interface UserProfileResponse extends BaseResponse {
+    data: UserProfile;
+}
+interface IAuthService {
+    checkEmailExists(email: string): Promise<EmailExistResponse>;
+    login(credentials: LoginRequest): Promise<LoginResponse>;
+    verifyEmail(verification: VerifyEmailRequest): Promise<VerifyEmailResponse>;
+    getUserProfile(): Promise<UserProfileResponse>;
+}
+
+interface AuthActionState {
+    isLoading: boolean;
+    error: string | null;
+    success: string | null;
+}
+interface AuthActionCallbacks<T = unknown> {
+    onSuccess?: (data: T, message?: string, result?: AuthActionResult<T>) => void;
+    onError?: (error: string) => void;
+}
+interface AuthActionOptions<T = unknown> extends AuthActionCallbacks<T> {
+    clearStatesBeforeAction?: boolean;
+    preserveSuccessOnError?: boolean;
+}
+interface BaseAuthActionResult {
+    message: string;
+    nextAction?: NextAction;
+}
+interface AuthActionResultSuccess<T = unknown> extends BaseAuthActionResult {
+    success: true;
+    data: T;
+}
+interface AuthActionResultFailure extends BaseAuthActionResult {
+    success: false;
+    error: string;
+}
+type AuthActionResult<T = unknown> = AuthActionResultSuccess<T> | AuthActionResultFailure;
+interface UseAuthActionHandler {
+    state: AuthActionState;
+    executeAction: <T = unknown>(action: () => Promise<AuthActionResult<T>>, options?: AuthActionOptions<T>) => Promise<AuthActionResult<T> | null>;
+    clearError: () => void;
+    clearSuccess: () => void;
+    clearAll: () => void;
+    setSuccess: (message: string) => void;
+    setError: (error: string) => void;
+}
+interface UseAuthEventBusProps {
+    onLoggedOut?: () => void;
+    onLoggedIn?: () => void;
+}
+interface UseFormSubmissionProps<T> {
+    onSubmit: (values: T) => void | Promise<void>;
+    onError?: (error: unknown) => void;
+}
+
+/**
+ * Authentication Orchestrator Interface
+ * Follows Interface Segregation Principle (ISP)
+ */
+interface IAuthOrchestrator {
+    handleEmailCheck(email: string): Promise<AuthActionResult>;
+    handleLoginFlow(credentials: LoginRequest): Promise<AuthActionResult>;
+    handleEmailVerification(email: string, code: string): Promise<AuthActionResult>;
+    handleLogout(): Promise<AuthActionResult>;
+    checkAuthenticationStatus(): Promise<AuthActionResult>;
+    getUserProfileData(): Promise<AuthActionResult>;
+    getTokenInfo(): Promise<AuthActionResult>;
+}
+
+declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH"
+}
+interface ApiKeyConfig {
+    apiKey: string;
+    headerName?: string;
+}
+interface HttpClientConfig {
+    baseURL: string;
+    timeout?: number;
+    retries?: number;
+    apiKey?: ApiKeyConfig;
+    apiKeys?: Record<string, string>;
+    origin?: string;
+    headers?: Record<string, string>;
+    getAccessToken?: () => Promise<string | null>;
+}
+interface HttpRequestOptions {
+    method: HttpMethod;
+    url: string;
+    data?: unknown;
+    body?: unknown;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+interface HttpResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    ok: boolean;
+}
+interface ApiErrorResponse {
+    message: string;
+    statusCode: number;
+    error: string;
+    digest?: string;
+}
+interface HttpError extends Error {
+    status?: number;
+    statusText?: string;
+    response?: unknown;
+}
+
+interface AlertDisplayProps {
+    error?: string;
+    success?: string;
+}
+
+interface FormHeaderProps {
+    title: string;
+    description?: string;
+}
+
+interface BaseFormField extends Omit<FormItemProps, 'children'> {
+    component: React.ReactNode;
+}
+interface FormFieldsProps {
+    fields: BaseFormField[];
+}
+
+interface BaseComponentProps extends FormHeaderProps, AlertDisplayProps {
+    submitButtonText: string;
+    isLoading?: boolean;
+    initialValues?: Store;
+}
+type BaseStepProps = BaseComponentProps;
+interface BaseFormProps<T = Record<string, unknown>> extends BaseComponentProps, FormFieldsProps {
+    onSubmit: (values: T) => void | Promise<void>;
+    form?: FormInstance;
+    additionalActions?: React.ReactNode;
+    showAlerts?: boolean;
+}
+
+interface EmailStepProps extends BaseStepProps {
+    onSubmit: (email: string) => void | Promise<void>;
+    onGoogleSignIn?: () => void;
+    onForgotPassword?: () => void;
+    showGoogleButton?: boolean;
+    showForgotPassword?: boolean;
+}
+
+interface PasswordStepProps extends BaseStepProps {
+    mode: NextAction;
+    email: string;
+    onSubmit: (password: string) => void | Promise<void>;
+    onBack?: () => void;
+    showEmailField?: boolean;
+    showBackButton?: boolean;
+}
+
+interface VerificationStepProps extends BaseStepProps {
+    email: string;
+    onSubmit: (verificationCode: string) => void | Promise<void>;
+    onBack?: () => void;
+    onResendCode?: () => void;
+    codeLength?: number;
+    showBackButton?: boolean;
+    showResendButton?: boolean;
+}
+
+declare enum ProfileUIState {
+    LOADING = "LOADING",
+    UNAUTHENTICATED = "UNAUTHENTICATED",
+    AUTHENTICATED = "AUTHENTICATED"
+}
+interface AuthenticatedStateProps {
+    user: UserProfile;
+    onLogout: () => void;
+}
+
+interface Step<T = string> {
+    id: T;
+    title: string;
+    description: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+interface StepConfig<T = string> {
+    steps: Step<T>[];
+    initialStep?: T;
+}
+interface StepperState$1<T = string> {
+    currentStep: T;
+    currentStepIndex: number;
+    steps: Step<T>[];
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    progress: number;
+}
+interface StepperActions<T = string> {
+    goToStep: (step: T) => void;
+    goToNext: () => void;
+    goToPrevious: () => void;
+    goToIndex: (index: number) => void;
+    reset: () => void;
+}
+interface UseStepperReturn<T = string> {
+    state: StepperState$1<T>;
+    actions: StepperActions<T>;
+    helpers: {
+        getStepIndex: (step: T) => number;
+        getStepByIndex: (index: number) => Step<T> | undefined;
+        isStepValid: (step: T) => boolean;
+        getProgressPercentage: () => number;
+    };
+}
+
+type StepRegistryBaseProps = Omit<BaseStepProps, 'title' | 'description' | 'submitButtonText'>;
+interface StepRegistryParams {
+    baseProps: StepRegistryBaseProps;
+    handlers: StepRegistryHandlers;
+    state: StepRegistryState;
+    configs: StepRegistryConfigs;
+}
+interface UseStepRegistryParams extends StepRegistryParams {
+    getStepComponent: (step: AuthFlowStep) => StepComponent | null;
+    stepperState: StepperState;
+}
+interface StepRegistryHandlers {
+    handleEmailSubmit: (email: string) => Promise<void>;
+    handlePasswordSubmit: (password: string) => Promise<void>;
+    handleVerificationSubmit: (code: string) => Promise<void>;
+    handleResendCode: () => void;
+    goBackToEmail: () => void;
+    goBackToPassword: () => void;
+    onGoogleSignIn?: () => void;
+    onForgotPassword?: () => void;
+}
+interface StepRegistryState {
+    email: string;
+    authIntent: NextAction;
+    authData: unknown;
+}
+interface StepRegistryConfigs {
+    emailStepConfig: Record<string, unknown>;
+    passwordStepConfig: Record<string, unknown>;
+    verificationStepConfig: Record<string, unknown>;
+}
+interface StepperState {
+    currentStep: AuthFlowStep;
+}
+type StepComponentRetriever = (step: AuthFlowStep) => StepComponent | null;
+type AnyStepProps = EmailStepProps | PasswordStepProps | VerificationStepProps;
+type StepComponent = React__default.ComponentType<AnyStepProps>;
+type StepRegistry = Record<AuthFlowStep, StepComponent>;
+type PropsFactory = () => AnyStepProps;
+type StepPropsFactoryRegistry = Record<AuthFlowStep, PropsFactory>;
+
+/**
+ * Enum for user roles
+ */
+declare enum RoleType {
+    USER = "USER",
+    ADMIN = "ADMIN"
+}
+type AuthState = {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: string | null;
+    user: Record<string, unknown> | null;
+    tokens: {
+        accessToken: string | null;
+        refreshToken: string | null;
+    };
+};
+type EmailCheckResult = {
+    exists: boolean;
+    nextAction: NextAction;
+    message: string;
+};
+type UserSession = {
+    user: {
+        id: string;
+        email: string;
+        firstName: string;
+        lastName: string;
+        role: RoleType;
+    };
+    tokens: {
+        accessToken: string;
+        refreshToken: string;
+    };
+    expiresAt: number;
+};
+type UserState = {
+    user: UserProfile | null;
+    isLoading: boolean;
+    error: string | null;
+    isAuthenticated: boolean;
+};
+
+/**
+ * Token Management Interface
+ * Follows Single Responsibility Principle (SRP)
+ * Updated to support async operations for SSR compatibility
+ */
+interface ITokenManager {
+    saveTokens(accessToken: string, refreshToken?: string): void;
+    clearTokens(): void;
+    getAccessToken(): Promise<string | null>;
+    getRefreshToken(): Promise<string | null>;
+    getAllTokens(): Promise<Record<string, string>>;
+    areCookiesSupported(): boolean;
+    getDomainInfo(): Record<string, string>;
+}
+
+/**
+ * Strategy Pattern: Login Flow Strategy Interface
+ */
+interface ILoginFlowStrategy {
+    execute(credentials: LoginRequest): Promise<AuthActionResult<LoginData>>;
+}
+
+/**
+ * State Pattern: Authentication Status State Interface
+ */
+interface IAuthStatusState {
+    getStatus(tokenManager: ITokenManager): Promise<AuthActionResult>;
+}
+
+/**
+ * Chain of Responsibility: Error Handler Interface
+ */
+interface IErrorHandler {
+    setNext(handler: IErrorHandler): IErrorHandler;
+    handle(error: unknown, context: string): AuthActionResult;
+}
+
+/**
+ * Lookup Pattern: Logger Interface
+ */
+interface ILogger {
+    log(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+}
+
+interface Subscription {
+    unsubscribe(): void;
+}
+interface EventBus<TEvent = unknown> {
+    publish(event: TEvent): void;
+    subscribe(handler: (event: TEvent) => void): Subscription;
+}
+declare abstract class BaseEventBus {
+}
+
+declare enum AuthEventType {
+    LoggedIn = "auth.logged_in",
+    LoggedOut = "auth.logged_out",
+    EmailVerified = "auth.email_verified",
+    SignInRequiredModal = "auth.signin_required_modal"
+}
+type AuthEvent = {
+    type: AuthEventType.LoggedIn;
+    userId: string;
+    sourcePageType?: PageType;
+} | {
+    type: AuthEventType.LoggedOut;
+    sourcePageType?: PageType;
+} | {
+    type: AuthEventType.EmailVerified;
+    email: string;
+    sourcePageType?: PageType;
+} | {
+    type: AuthEventType.SignInRequiredModal;
+    sourcePageType?: PageType;
+};
+declare enum PageType {
+    LOGIN = "/login",
+    DASHBOARD = "/dashboard",
+    HOME = "/"
+}
+declare enum NavigationAction {
+    NONE = "none",
+    REDIRECT = "redirect",
+    MODAL = "modal"
+}
+declare const PageTypePatterns: {
+    readonly "/login": PageType.LOGIN;
+    readonly "/dashboard": PageType.DASHBOARD;
+    readonly "/": PageType.HOME;
+};
+declare const CrossTabBehaviorConfig: {
+    readonly "/login": {
+        readonly "auth.logged_in": {
+            readonly action: NavigationAction.REDIRECT;
+            readonly target: PageType.DASHBOARD;
+        };
+        readonly "auth.logged_out": {
+            readonly action: NavigationAction.NONE;
+        };
+        readonly "auth.email_verified": {
+            readonly action: NavigationAction.NONE;
+        };
+        readonly "auth.signin_required_modal": {
+            readonly action: NavigationAction.NONE;
+        };
+    };
+    readonly "/dashboard": {
+        readonly "auth.logged_in": {
+            readonly action: NavigationAction.MODAL;
+        };
+        readonly "auth.logged_out": {
+            readonly action: NavigationAction.REDIRECT;
+            readonly target: PageType.DASHBOARD;
+        };
+        readonly "auth.email_verified": {
+            readonly action: NavigationAction.MODAL;
+        };
+        readonly "auth.signin_required_modal": {
+            readonly action: NavigationAction.NONE;
+        };
+    };
+    readonly "/": {
+        readonly "auth.logged_in": {
+            readonly action: NavigationAction.MODAL;
+        };
+        readonly "auth.logged_out": {
+            readonly action: NavigationAction.REDIRECT;
+            readonly target: PageType.HOME;
+        };
+        readonly "auth.email_verified": {
+            readonly action: NavigationAction.MODAL;
+        };
+        readonly "auth.signin_required_modal": {
+            readonly action: NavigationAction.NONE;
+        };
+    };
+};
+
+/**
+ * Middleware request context containing all necessary data
+ */
+interface MiddlewareContext {
+    request: NextRequest;
+    method: string;
+    pathname: string;
+    searchParams: URLSearchParams;
+    cookies: NextRequest['cookies'];
+    nextUrl: URL;
+}
+/**
+ * Base interface for middleware handlers
+ */
+interface MiddlewareHandler {
+    handle(context: MiddlewareContext): NextResponse | null | Promise<NextResponse | null>;
+}
+
+declare enum Channel {
+    AUTH = "auth-event-channel"
+}
+
+declare const createAuthSteps: (options?: {
+    authIntent?: NextAction;
+    nextAction?: NextAction;
+}) => Step<AuthFlowStep>[];
+declare const getStepProgressMessage: (step: AuthFlowStep) => string;
+declare const getAuthPageStepMessage: (step: AuthFlowStep) => string;
+
+declare const EMAIL_SUBMISSION_NAVIGATION: {
+    readonly "login-verification": AuthFlowStep.VERIFICATION;
+    readonly login: AuthFlowStep.PASSWORD;
+    readonly signup: AuthFlowStep.PASSWORD;
+};
+declare const PASSWORD_SUBMISSION_NAVIGATION: {
+    readonly VERIFIED: AuthFlowStep.VERIFICATION;
+    readonly UNVERIFIED: AuthFlowStep.VERIFICATION;
+};
+declare const VERIFICATION_SUBMISSION_NAVIGATION: {
+    readonly SUCCESS: AuthFlowStep.VERIFICATION;
+    readonly ERROR: AuthFlowStep.VERIFICATION;
+};
+declare const getStepForEmailSubmission: (nextAction: NextAction) => AuthFlowStep;
+declare const getStepForPasswordSubmission: (isVerified: boolean) => AuthFlowStep;
+declare const getStepForVerificationSubmission: (success: boolean) => AuthFlowStep;
+
+declare const getEmailField: (options?: InputProps) => BaseFormField;
+declare const getPasswordField: (isLogin: boolean, disabled?: boolean, options?: PasswordProps) => BaseFormField;
+declare const getVerificationField: (codeLength?: number, options?: InputProps) => BaseFormField;
+
+/**
+ * Middleware configuration constants
+ */
+declare class MiddlewareConfig {
+    static readonly PROTECTED_ROUTES: {
+        readonly DASHBOARD: "/";
+    };
+    static readonly AUTH_ROUTES: {
+        readonly LOGIN: "/login";
+    };
+    static readonly ALLOWED_METHODS: readonly ["GET", "HEAD"];
+    static readonly QUERY_PARAMS: {
+        readonly LOGIN_REQUIRED: "sign_in_required";
+        readonly AUTH_CHECKED: "auth_checked";
+    };
+    static readonly QUERY_VALUES: {
+        readonly LOGIN_REQUIRED: "true";
+        readonly AUTH_CHECKED: "1";
+    };
+}
+/**
+ * Middleware matcher patterns - exported separately for static analysis
+ * Pattern includes:
+ * - / (home route and all other routes for authentication protection)
+ * - /login route (for authenticated user redirection)
+ * Excludes: API routes, Next.js internals, static assets, and file extensions
+ */
+declare const middlewareMatcher: readonly ["/((?!api|_next/static|_next/image|_next/webpack-hmr|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp|ico|css|js)$).*)", "/login"];
+/**
+ * Middleware configuration - runs on all routes (including home) and login page
+ */
+declare const config: {
+    matcher: readonly ["/((?!api|_next/static|_next/image|_next/webpack-hmr|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp|ico|css|js)$).*)", "/login"];
+};
+
+/**
+ * Cookie utility for managing authentication tokens with automatic SSR and client-side support
+ * Automatically chooses the right method based on environment
+ */
+declare class CookieUtils {
+    /**
+     * Get the access token cookie key from environment variables
+     */
+    static getAccessTokenKey(): string;
+    /**
+     * Get the refresh token cookie key from environment variables
+     */
+    static getRefreshTokenKey(): string;
+    private static readonly COOKIE_DOMAIN;
+    /**
+     * Get root domain for subdomain support
+     */
+    private static getRootDomain;
+    /**
+     * Get common cookie options
+     */
+    private static getCookieOptions;
+    /**
+     * Check if running on client side
+     */
+    private static isClientSide;
+    /**
+     * Check if running on server side
+     */
+    private static isServerSide;
+    /**
+     * Dynamically import server action for server-side operations
+     */
+    private static getServerTokens;
+    /**
+     * Set access token in cookie (client-side only)
+     */
+    static setAccessToken(token: string): void;
+    /**
+     * Set refresh token in cookie (client-side only)
+     */
+    static setRefreshToken(token: string): void;
+    /**
+     * Get access token - automatically handles client/server side
+     */
+    static getAccessToken(): Promise<string | null>;
+    /**
+     * Get refresh token - automatically handles client/server side
+     */
+    static getRefreshToken(): Promise<string | null>;
+    /**
+     * Get both tokens - automatically handles client/server side
+     */
+    static getTokens(): Promise<{
+        accessToken: string | null;
+        refreshToken: string | null;
+    }>;
+    /**
+     * Clear all authentication cookies (client-side only)
+     */
+    static clearAuthCookies(): void;
+    /**
+     * Check if cookies are supported/enabled (client-side only)
+     */
+    static areCookiesEnabled(): boolean;
+    /**
+     * Get all authentication cookies - automatically handles client/server side
+     */
+    static getAllAuthCookies(): Promise<Record<string, string>>;
+    /**
+     * Set multiple tokens at once (client-side only)
+     */
+    static setTokens(accessToken: string, refreshToken: string): void;
+    /**
+     * Check if user has valid tokens - automatically handles client/server side
+     */
+    static hasValidTokens(): Promise<boolean>;
+    /**
+     * Get current domain information for debugging
+     */
+    static getDomainInfo(): Record<string, string>;
+}
+
+/**
+ * LocalStorage utility for managing user profile data with automatic caching and expiration
+ */
+declare class LocalStorageUtils {
+    private static readonly USER_PROFILE_STORAGE_KEY;
+    private static readonly USER_PROFILE_TIMESTAMP_KEY;
+    private static readonly DEFAULT_CACHE_DURATION;
+    /**
+     * Check if localStorage is available
+     */
+    private static isAvailable;
+    /**
+     * Save user profile to localStorage with timestamp
+     */
+    static saveUserProfile(userProfile: UserProfile): boolean;
+    /**
+     * Get user profile from localStorage with cache validation
+     */
+    static getUserProfile(cacheDuration?: number): UserProfile | null;
+    /**
+     * Clear user profile data from localStorage
+     */
+    static clearUserProfile(): boolean;
+    /**
+     * Check if cached user profile is still valid
+     */
+    static isCacheValid(cacheDuration?: number): boolean;
+}
+
+type Handler<T> = (e: T) => void;
+declare class BroadcastChannelEventBus<TEvent> {
+    private channel?;
+    private readonly listeners;
+    private readonly name;
+    private constructor();
+    static getInstance<T>(name: Channel): BroadcastChannelEventBus<T>;
+    publish(event: TEvent): void;
+    subscribe(handler: Handler<TEvent>): {
+        unsubscribe: () => boolean;
+    };
+    private emit;
+    close(): void;
+}
+
+/**
+ * Cross-Tab Behavior Handler
+ * Determines cross-tab behavior based on authentication events and current page context
+ * Uses lookup patterns instead of conditional statements
+ */
+declare class CrossTabBehaviorHandler {
+    /**
+     * Get current page type based on pathname using pattern matching
+     */
+    static getCurrentPageType(): PageType;
+    /**
+     * Get the action configuration for current route and event
+     */
+    static getAction(currentPageType: PageType, eventType: AuthEventType): {
+        readonly action: NavigationAction.REDIRECT;
+        readonly target: PageType.DASHBOARD;
+    } | {
+        readonly action: NavigationAction.NONE;
+    } | {
+        readonly action: NavigationAction.NONE;
+    } | {
+        readonly action: NavigationAction.NONE;
+    } | {
+        readonly action: NavigationAction.MODAL;
+    } | {
+        readonly action: NavigationAction.REDIRECT;
+        readonly target: PageType.DASHBOARD;
+    } | {
+        readonly action: NavigationAction.MODAL;
+    } | {
+        readonly action: NavigationAction.NONE;
+    } | {
+        readonly action: NavigationAction.MODAL;
+    } | {
+        readonly action: NavigationAction.REDIRECT;
+        readonly target: PageType.HOME;
+    } | {
+        readonly action: NavigationAction.MODAL;
+    } | {
+        readonly action: NavigationAction.NONE;
+    };
+    /**
+     * Check if current route requires redirect for given event
+     */
+    static shouldRedirect(currentPageType: PageType, eventType: AuthEventType): PageType | null;
+    /**
+     * Check if current route should show modal for given event
+     */
+    static shouldShowModal(currentPageType: PageType, eventType: AuthEventType): boolean;
+}
+
+/**
+ * Token Manager Implementation
+ * Handles token storage and validation using CookieUtils
+ * Updated to support async operations for SSR compatibility
+ */
+declare class TokenManager implements ITokenManager {
+    private cookieUtils;
+    constructor(cookieUtils: typeof CookieUtils);
+    saveTokens(accessToken: string, refreshToken?: string): void;
+    clearTokens(): void;
+    getAccessToken(): Promise<string | null>;
+    getRefreshToken(): Promise<string | null>;
+    /**
+     * Get all stored tokens for debugging or validation
+     */
+    getAllTokens(): Promise<Record<string, string>>;
+    /**
+     * Check if cookies are supported in the current environment
+     */
+    areCookiesSupported(): boolean;
+    /**
+     * Get domain information for debugging
+     */
+    getDomainInfo(): Record<string, string>;
+}
+
+/**
+ * HTTP Client with better error handling
+ */
+declare class HttpClient {
+    private config;
+    constructor(config: HttpClientConfig);
+    /**
+     * Execute HTTP request
+     */
+    request<T>(endpoint: string, options: HttpRequestOptions): Promise<HttpResponse<T>>;
+    /**
+     * Build headers with defaults including multiple API keys and Bearer token
+     */
+    private buildHeaders;
+    /**
+     * Execute request with timeout
+     */
+    private executeWithTimeout;
+}
+/**
+ * Base Service with dependency injection and better separation of concerns
+ */
+declare abstract class BaseService {
+    protected httpClient: HttpClient;
+    protected tokenManager: TokenManager;
+    constructor(httpClient?: HttpClient, tokenManager?: TokenManager);
+    /**
+     * Create default HTTP client with configuration
+     */
+    private createDefaultHttpClient;
+    /**
+     * Handle HTTP response and throw structured error if needed
+     */
+    private handleResponse;
+    /**
+     * Create API error from HTTP response following Single Responsibility Principle
+     */
+    private createApiErrorFromResponse;
+    /**
+     * Try to parse API error response from response data
+     */
+    private tryParseApiErrorResponse;
+    /**
+     * Check if response data has valid API error structure
+     */
+    private isValidApiErrorResponse;
+    /**
+     * Create generic API error as fallback
+     */
+    private createGenericApiError;
+    /**
+     * GET request
+     */
+    protected get<T>(endpoint: string, headers?: Record<string, string>): Promise<T>;
+    /**
+     * POST request
+     */
+    protected post<T>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    /**
+     * PUT request
+     */
+    protected put<T>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    /**
+     * DELETE request
+     */
+    protected delete<T>(endpoint: string, headers?: Record<string, string>): Promise<T>;
+    /**
+     * PATCH request
+     */
+    protected patch<T>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+}
+
+/**
+ * Authentication Service
+ * Handles all authentication-related operations with clean separation of concerns
+ */
+declare class AuthService extends BaseService implements IAuthService {
+    /**
+     * Check if an email exists in the system
+     */
+    checkEmailExists(email: string): Promise<EmailExistResponse>;
+    /**
+     * Login with email and password
+     */
+    login(credentials: LoginRequest): Promise<LoginResponse>;
+    /**
+     * Verify email with verification code
+     */
+    verifyEmail(verification: VerifyEmailRequest): Promise<VerifyEmailResponse>;
+    /**
+     * Get user profile
+     */
+    getUserProfile(): Promise<UserProfileResponse>;
+    /**
+     * Logout user
+     */
+    logout(): Promise<void>;
+}
+
+/**
+ * Authentication API endpoints
+ */
+declare const AUTH_ENDPOINTS: {
+    readonly CHECK_EMAIL_EXISTS: (email: string) => string;
+    readonly LOGIN: "/auth/user/login";
+    readonly VERIFY_EMAIL: "/auth/user/verify";
+    readonly GET_USER_PROFILE: "/auth/user/profile";
+    readonly LOGOUT: "/auth/logout";
+};
+/**
+ * Endpoint builder utility
+ */
+declare class EndpointBuilder {
+    static auth: {
+        readonly CHECK_EMAIL_EXISTS: (email: string) => string;
+        readonly LOGIN: "/auth/user/login";
+        readonly VERIFY_EMAIL: "/auth/user/verify";
+        readonly GET_USER_PROFILE: "/auth/user/profile";
+        readonly LOGOUT: "/auth/logout";
+    };
+}
+
+/**
+ * Authentication Orchestrator Service
+ * Orchestrates authentication flow with proper separation of concerns
+ * Follows Dependency Inversion Principle (DIP) and Open/Closed Principle (OCP)
+ */
+declare class AuthOrchestrator implements IAuthOrchestrator {
+    private authService;
+    private eventBus;
+    private tokenManager;
+    private userStorageManager;
+    private errorHandler;
+    private logger;
+    constructor(authService: AuthService, eventBus: EventBus<AuthEvent>, tokenManager?: ITokenManager);
+    /**
+     * Setup Chain of Responsibility for error handling
+     */
+    private setupErrorHandlerChain;
+    /**
+     * Validate that cookies are supported in the current environment
+     */
+    private validateCookieSupport;
+    /**
+     * Handle email check to determine if user exists and what action to take
+     */
+    handleEmailCheck(email: string): Promise<AuthActionResult<EmailExistResponse>>;
+    /**
+     * Handle complete login flow with proper error handling and token management
+     */
+    handleLoginFlow(credentials: LoginRequest): Promise<AuthActionResult<LoginData>>;
+    /**
+     * Handle email verification flow
+     */
+    handleEmailVerification(email: string, code: string): Promise<AuthActionResult>;
+    /**
+     * Handle logout flow
+     */
+    handleLogout(): Promise<AuthActionResult>;
+    /**
+     * Check current authentication status using State Pattern
+     */
+    checkAuthenticationStatus(): Promise<AuthActionResult>;
+    /**
+     * Get user profile data
+     */
+    getUserProfileData(): Promise<AuthActionResult>;
+    /**
+     * Get detailed token information
+     */
+    getTokenInfo(): Promise<AuthActionResult>;
+}
+/**
+ * Authentication Orchestrator Factory
+ * Follows Factory Pattern for dependency injection
+ */
+declare class AuthOrchestratorFactory {
+    /**
+     * Create AuthOrchestrator with default dependencies
+     */
+    static create(): AuthOrchestrator;
+    /**
+     * Create AuthOrchestrator with custom dependencies
+     */
+    static createWithDependencies(authService: AuthService, eventBus: EventBus<AuthEvent>, tokenManager?: ITokenManager): AuthOrchestrator;
+}
+
+/**
+ * User Storage Manager Implementation
+ * Handles user profile storage using LocalStorageUtils
+ * Provides a clean interface for user data persistence
+ */
+declare class UserStorageManager {
+    private storageUtils;
+    constructor(storageUtils: typeof LocalStorageUtils);
+    /**
+     * Save user profile data to storage
+     */
+    saveUserProfile(userProfile: UserProfile): boolean;
+    /**
+     * Get user profile data from storage
+     */
+    getUserProfile(cacheDuration?: number): UserProfile | null;
+    /**
+     * Clear user profile data from storage
+     */
+    clearUserProfile(): boolean;
+    /**
+     * Check if cached user profile is still valid
+     */
+    isCacheValid(cacheDuration?: number): boolean;
+    /**
+     * Get user profile with automatic cache validation
+     * Returns null if cache is expired or invalid
+     */
+    getValidUserProfile(cacheDuration?: number): UserProfile | null;
+}
+
+/**
+ * Strategy Pattern: Signup Flow Strategy
+ */
+declare class SignupFlowStrategy implements ILoginFlowStrategy {
+    private authService;
+    private tokenManager;
+    constructor(authService: AuthService, tokenManager: ITokenManager);
+    execute(credentials: LoginRequest): Promise<AuthActionResult<LoginData>>;
+    private handleSuccessfulAuthentication;
+}
+
+/**
+ * Strategy Pattern: Existing User Login Strategy
+ */
+declare class ExistingUserLoginStrategy implements ILoginFlowStrategy {
+    private authService;
+    private tokenManager;
+    constructor(authService: AuthService, tokenManager: ITokenManager);
+    execute(credentials: LoginRequest): Promise<AuthActionResult<LoginData>>;
+    private handleSuccessfulAuthentication;
+}
+
+/**
+ * Strategy Pattern: Login Flow Strategy Factory
+ */
+declare class LoginFlowStrategyFactory {
+    private static strategies;
+    static createStrategy(action: NextAction, authService: AuthService, tokenManager: ITokenManager): ILoginFlowStrategy;
+}
+
+/**
+ * State Pattern: Authenticated State
+ */
+declare class AuthenticatedState implements IAuthStatusState {
+    getStatus(tokenManager: ITokenManager): Promise<AuthActionResultSuccess<{
+        isAuthenticated: boolean;
+        hasAccessToken: boolean;
+        hasRefreshToken: boolean;
+        cookiesSupported: boolean;
+        domainInfo: Record<string, string>;
+    }>>;
+    private buildAuthStatus;
+}
+
+/**
+ * State Pattern: Unauthenticated State
+ */
+declare class UnauthenticatedState implements IAuthStatusState {
+    getStatus(tokenManager: ITokenManager): Promise<AuthActionResultFailure>;
+    private buildAuthStatus;
+}
+
+/**
+ * State Pattern: Authentication Status Context
+ */
+declare class AuthenticationStatusContext {
+    private static states;
+    static getStatus(tokenManager: ITokenManager): Promise<AuthActionResult>;
+}
+
+/**
+ * Command Pattern: Result Creation Commands
+ * Follows Single Responsibility Principle - only responsible for creating AuthResult objects
+ */
+declare class AuthResultFactory {
+    /**
+     * Creates a successful authentication result
+     */
+    static createSuccess<T = unknown>(message: string, data: T): AuthActionResultSuccess<T>;
+    /**
+     * Creates a failed authentication result
+     */
+    static createFailure(message: string, error?: string | Error | unknown): AuthActionResultFailure;
+}
+
+/**
+ * Chain of Responsibility: Base Error Handler
+ */
+declare abstract class BaseErrorHandler implements IErrorHandler {
+    private nextHandler?;
+    setNext(handler: IErrorHandler): IErrorHandler;
+    handle(error: unknown, context: string): AuthActionResult;
+    protected abstract canHandle(error: unknown): boolean;
+    protected abstract handleError(error: unknown, context: string): AuthActionResult;
+}
+
+/**
+ * Validation Error Handler
+ */
+declare class ValidationErrorHandler extends BaseErrorHandler {
+    protected canHandle(error: unknown): boolean;
+    protected handleError(error: unknown, context: string): AuthActionResult;
+}
+
+/**
+ * Network Error Handler
+ */
+declare class NetworkErrorHandler extends BaseErrorHandler {
+    protected canHandle(error: unknown): boolean;
+    protected handleError(error: unknown, context: string): AuthActionResult;
+}
+
+/**
+ * Generic Error Handler
+ */
+declare class GenericErrorHandler extends BaseErrorHandler {
+    protected canHandle(_error: unknown): boolean;
+    protected handleError(error: unknown, context: string): AuthActionResult;
+}
+
+/**
+ * Development Logger Implementation
+ */
+declare class DevelopmentLogger implements ILogger {
+    log(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+}
+
+/**
+ * Production Logger Implementation
+ */
+declare class ProductionLogger implements ILogger {
+    log(_message: string, _data?: unknown): void;
+    warn(_message: string, _data?: unknown): void;
+    error(_message: string, _data?: unknown): void;
+}
+
+/**
+ * Lookup Pattern: Logger Factory with Environment-based Strategy
+ */
+declare class LoggerFactory {
+    private static loggers;
+    static create(environment?: string): ILogger;
+}
+
+/**
+ * User store state interface
+ */
+interface UserStoreState {
+    user: UserProfile | null;
+    isLoading: boolean;
+    error: string | null;
+    isAuthenticated: boolean;
+    setUser: (user: UserProfile | null) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    clearUser: () => Promise<void>;
+    refreshUser: (forceRefresh?: boolean) => Promise<void>;
+    _authOrchestrator: AuthOrchestrator;
+    _userStorageManager: UserStorageManager;
+}
+/**
+ * Create the user store with Zustand
+ */
+declare const useUserStore: zustand.UseBoundStore<Omit<Omit<Omit<zustand.StoreApi<UserStoreState>, "setState" | "devtools"> & {
+    setState(partial: UserStoreState | Partial<UserStoreState> | ((state: UserStoreState) => UserStoreState | Partial<UserStoreState>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: UserStoreState | ((state: UserStoreState) => UserStoreState), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: UserStoreState, previousSelectedState: UserStoreState) => void): () => void;
+        <U>(selector: (state: UserStoreState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: UserStoreState | Partial<UserStoreState> | ((state: immer.WritableDraft<UserStoreState>) => void), shouldReplace?: false, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(nextStateOrUpdater: UserStoreState | ((state: immer.WritableDraft<UserStoreState>) => void), shouldReplace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+}>;
+/**
+ * Selectors for accessing store state
+ * These provide a clean interface and are optimized for performance using useShallow
+ */
+declare const userSelectors: {
+    useUser: () => UserProfile | null;
+    useIsAuthenticated: () => boolean;
+    useIsLoading: () => boolean;
+    useError: () => string | null;
+    useUserState: () => {
+        user: UserProfile | null;
+        isAuthenticated: boolean;
+        isLoading: boolean;
+        error: string | null;
+    };
+    useActions: () => {
+        setUser: (user: UserProfile | null) => void;
+        setLoading: (loading: boolean) => void;
+        setError: (error: string | null) => void;
+        clearUser: () => Promise<void>;
+        refreshUser: (forceRefresh?: boolean) => Promise<void>;
+    };
+};
+
+declare const AuthFlowContainer: React__default.FC;
+
+declare const AuthFlowModal: ({ children }: {
+    children: React__default.ReactNode;
+}) => React__default.JSX.Element;
+
+/**
+ * Auth Initializer Component
+ * Initializes the auth event bus and user store without requiring a provider
+ */
+declare const AuthInitializer: ({ children }: {
+    children: React.ReactNode;
+}) => React.ReactElement;
+
+declare const BaseForm: <T>({ title, description, fields, submitButtonText, onSubmit, isLoading, error, success, form, additionalActions, showAlerts, initialValues }: BaseFormProps<T>) => React__default.JSX.Element;
+
+declare const EmailStep: React__default.FC<EmailStepProps>;
+
+declare const PasswordStep: React__default.FC<PasswordStepProps>;
+
+declare const VerificationStep: React__default.FC<VerificationStepProps>;
+
+declare const getEmailStepComponent: StepComponent;
+declare const getPasswordStepComponent: StepComponent;
+declare const getVerificationStepComponent: StepComponent;
+declare const createStepRegistry: () => StepRegistry;
+declare const createPropsFactoryRegistry: ({ baseProps, handlers, state, configs }: StepRegistryParams) => StepPropsFactoryRegistry;
+declare const useStepRenderer: () => {
+    getStepComponent: (step: AuthFlowStep) => StepComponent | null;
+};
+
+declare const AlertDisplay: ({ error, success }: AlertDisplayProps) => React__default.JSX.Element | null;
+
+declare const FormHeader: ({ title, description }: FormHeaderProps) => React__default.JSX.Element;
+
+declare const FormFields: ({ fields }: FormFieldsProps) => React__default.JSX.Element[];
+
+declare const ProfileStateRenderer: () => React__default.JSX.Element;
+
+/**
+ * Cross-Tab Authentication Demo Component
+ * Demonstrates the cross-tab authentication event handling
+ */
+declare const CrossTabDemo: React__default.FC;
+
+/**
+ * Custom hook for managing authentication action states and execution.
+ *
+ * This hook implements the DRY principle by centralizing common logic for:
+ * - Loading state management
+ * - Error handling and transformation
+ * - Success state management
+ * - Async action execution with consistent patterns
+ *
+ * @returns {UseAuthActionHandler} Object containing state and action handlers
+ */
+declare const useAuthActionHandler: () => UseAuthActionHandler;
+
+/**
+ * Custom hook for managing stepper logic with full type safety.
+ *
+ * This hook implements the Single Responsibility Principle by focusing solely on
+ * stepper state management and navigation logic.
+ *
+ * Features:
+ * - Type-safe step management
+ * - Automatic progress calculation
+ * - Step validation
+ * - Navigation helpers
+ * - Reset functionality
+ *
+ * @param config - Step configuration object
+ * @returns Stepper state, actions, and helper functions
+ */
+declare const useStepper: <T extends string>(config: StepConfig<T>) => UseStepperReturn<T>;
+
+declare function useStepRegistry({ baseProps: actionState, handlers, state, configs, getStepComponent, stepperState }: UseStepRegistryParams): {
+    SelectedComponent: React$1.ComponentType<AnyStepProps>;
+    stepProps: AnyStepProps | {
+        isLoading: boolean | undefined;
+        error: string | undefined;
+        success: string | undefined;
+    };
+};
+
+declare const useAuthEventBus: ({ onLoggedOut, onLoggedIn }?: UseAuthEventBusProps) => void;
+
+declare function useSharedEventBus(): BroadcastChannelEventBus<AuthEvent>;
+
+declare function useSignInRequiredParams(): void;
+
+/**
+ * Main hook for accessing user state and actions
+ * This is the primary interface components should use
+ */
+declare const useUser: () => {
+    setUser: (user: UserProfile | null) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    clearUser: () => Promise<void>;
+    refreshUser: (forceRefresh?: boolean) => Promise<void>;
+    user: UserProfile | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: string | null;
+};
+/**
+ * Hook for accessing only user data (optimized for components that only need state)
+ */
+declare const useUserData: () => {
+    user: UserProfile | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: string | null;
+};
+/**
+ * Hook for accessing only user actions (optimized for components that only need actions)
+ */
+declare const useUserActions: () => {
+    setUser: (user: UserProfile | null) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    clearUser: () => Promise<void>;
+    refreshUser: (forceRefresh?: boolean) => Promise<void>;
+};
+/**
+ * Hook for checking authentication status
+ */
+declare const useAuth: () => {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: string | null;
+    user: UserProfile | null;
+};
+/**
+ * Hook that initializes user authentication and sets up event handling
+ * Used for app-level initialization without requiring React Context
+ */
+declare const useAuthInitializer: () => {
+    setUser: (user: UserProfile | null) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    clearUser: () => Promise<void>;
+    refreshUser: (forceRefresh?: boolean) => Promise<void>;
+    user: UserProfile | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: string | null;
+};
+/**
+ * Specialized hooks for specific use cases
+ */
+/**
+ * Hook for components that only need to know if user is authenticated
+ */
+declare const useIsAuthenticated: () => boolean;
+/**
+ * Hook for components that only need loading state
+ */
+declare const useUserLoading: () => boolean;
+/**
+ * Hook for components that only need error state
+ */
+declare const useUserError: () => string | null;
+/**
+ * Hook for components that only need user profile data
+ */
+declare const useUserProfile: () => UserProfile | null;
+/**
+ * Hook for logout functionality with proper cleanup
+ */
+declare const useLogout: () => () => Promise<void>;
+/**
+ * Hook for refreshing user data
+ */
+declare const useRefreshUser: () => (force?: boolean) => Promise<void>;
+
+/**
+ * Custom hook to manage AuthFlowModal state
+ * Handles initial loading and modal visibility based on auth events
+ */
+declare const useAuthFlowModal: () => {
+    isModalOpen: boolean;
+    isInitialLoading: boolean;
+    openModal: () => void;
+};
+
+export { AUTH_ENDPOINTS, AlertDisplay, type AlertDisplayProps, type AnyStepProps, type ApiErrorResponse, type ApiKeyConfig, type AuthActionCallbacks, type AuthActionOptions, type AuthActionResult, type AuthActionResultFailure, type AuthActionResultSuccess, type AuthActionState, type AuthEvent, AuthEventType, AuthFlowContainer, AuthFlowModal, AuthFlowStep, AuthInitializer, AuthOrchestrator, AuthOrchestratorFactory, AuthResultFactory, AuthService, type AuthState, AuthenticatedState, type AuthenticatedStateProps, AuthenticationStatusContext, type BaseComponentProps, BaseErrorHandler, BaseEventBus, BaseForm, type BaseFormField, type BaseFormProps, type BaseResponse, BaseService, type BaseStepProps, BroadcastChannelEventBus, Channel, CookieUtils, CrossTabBehaviorConfig, CrossTabBehaviorHandler, CrossTabDemo, DevelopmentLogger, EMAIL_SUBMISSION_NAVIGATION, type EmailCheckResult, type EmailExistResponse, EmailStep, type EmailStepProps, EndpointBuilder, type EventBus, ExistingUserLoginStrategy, FormFields, type FormFieldsProps, FormHeader, type FormHeaderProps, GenericErrorHandler, HttpClient, type HttpClientConfig, type HttpError, HttpMethod, type HttpRequestOptions, type HttpResponse, type IAuthOrchestrator, type IAuthService, type IAuthStatusState, type IErrorHandler, type ILogger, type ILoginFlowStrategy, type ITokenManager, LocalStorageUtils, LoggerFactory, type LoginData, LoginFlowStrategyFactory, type LoginRequest, type LoginResponse, MiddlewareConfig, type MiddlewareContext, type MiddlewareHandler, NavigationAction, NetworkErrorHandler, NextAction, PASSWORD_SUBMISSION_NAVIGATION, PageType, PageTypePatterns, PasswordStep, type PasswordStepProps, ProductionLogger, ProfileStateRenderer, ProfileUIState, type PropsFactory, RoleType, SignupFlowStrategy, type Step, type StepComponent, type StepComponentRetriever, type StepConfig, type StepPropsFactoryRegistry, type StepRegistry, type StepRegistryBaseProps, type StepRegistryConfigs, type StepRegistryHandlers, type StepRegistryParams, type StepRegistryState, type StepperActions, type StepperState$1 as StepperState, type Subscription, TokenManager, UnauthenticatedState, type UseAuthActionHandler, type UseAuthEventBusProps, type UseFormSubmissionProps, type UseStepRegistryParams, type UseStepperReturn, type UserProfile, type UserProfileResponse, type UserSession, type UserState, UserStorageManager, type UserStoreState, VERIFICATION_SUBMISSION_NAVIGATION, ValidationErrorHandler, VerificationStep, type VerificationStepProps, type VerifyEmailRequest, type VerifyEmailResponse, config, createAuthSteps, createPropsFactoryRegistry, createStepRegistry, getAuthPageStepMessage, getEmailField, getEmailStepComponent, getPasswordField, getPasswordStepComponent, getStepForEmailSubmission, getStepForPasswordSubmission, getStepForVerificationSubmission, getStepProgressMessage, getVerificationField, getVerificationStepComponent, middlewareMatcher, useAuth, useAuthActionHandler, useAuthEventBus, useAuthFlowModal, useAuthInitializer, useIsAuthenticated, useLogout, useRefreshUser, useSharedEventBus, useSignInRequiredParams, useStepRegistry, useStepRenderer, useStepper, useUser, useUserActions, useUserData, useUserError, useUserLoading, useUserProfile, useUserStore, userSelectors };