mailsentry-auth 0.2.1 → 0.2.3

package/dist/index.d.mts

@@ -66,6 +66,8 @@ interface LoginData {
     tokenInfo: {
         domain: string;
     };
+    next_action?: NextAction;
+    loginRequest?: LoginRequest;
 }
 interface LoginResponse extends BaseResponse {
     data: LoginData;
@@ -209,531 +211,6 @@ interface UseFormSubmissionProps<T> {
     onError?: (error: unknown) => void;
 }
 
-/**
- * Authentication Orchestrator Interface
- * Follows Interface Segregation Principle (ISP)
- */
-interface IAuthOrchestrator {
-    handleEmailCheck(email: string): Promise<AuthActionResult>;
-    handleLoginFlow(credentials: LoginRequest): Promise<AuthActionResult>;
-    handleGoogleLogin(token: string): Promise<AuthActionResult>;
-    handleEmailVerification(email: string, code: string): Promise<AuthActionResult>;
-    handleLogout(): Promise<AuthActionResult>;
-    checkAuthenticationStatus(): Promise<AuthActionResult>;
-    getUserProfileData(): Promise<AuthActionResult>;
-    getMeData(): 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 FormHeaderProps {
-    title: string;
-    description?: string;
-}
-
-interface BaseFormField extends Omit<FormItemProps, 'children'> {
-    component: React.ReactNode;
-}
-interface FormFieldsProps {
-    fields: BaseFormField[];
-}
-
-interface BaseComponentProps extends FormHeaderProps {
-    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;
-}
-
-interface GoogleSignInActionsProps {
-    onGoogleSignIn?: (token: string) => void;
-    isLoading?: boolean;
-}
-
-interface EmailStepProps extends BaseStepProps, GoogleSignInActionsProps {
-    onSubmit: (email: string) => void | Promise<void>;
-    onForgotPassword?: () => void;
-}
-
-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;
-}
-
-interface ForgotPasswordStepProps extends BaseStepProps {
-    email: string;
-    onSubmit: (email: string) => void | Promise<void>;
-}
-
-declare enum AuthFlowVariant {
-    DEFAULT = "default",
-    WITH_IMAGE = "with_image"
-}
-type AuthFlowProps = {
-    variant?: AuthFlowVariant;
-    backgroundImage?: string;
-};
-type AuthFlowContainerProps = AuthFlowProps;
-type AuthFlowModalProps = AuthFlowProps & {
-    children: ReactNode;
-};
-
-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?: (token: string) => void;
-    handleForgotPassword?: (email: string) => Promise<void>;
-    onForgotPasswordClick?: () => 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 | ForgotPasswordStepProps;
-type StepComponent = React__default.ComponentType<AnyStepProps>;
-type StepRegistry = Record<AuthFlowStep, StepComponent>;
-type PropsFactory = () => AnyStepProps;
-type StepPropsFactoryRegistry = Record<AuthFlowStep, PropsFactory>;
-
-interface AlertDisplayProps {
-    error?: string;
-    success?: string;
-}
-
-interface PasswordStrengthRule {
-    label: string;
-    test: (password: string) => boolean;
-}
-interface StrengthResult {
-    label: string;
-    percent: number;
-    status: 'success' | 'exception' | 'normal';
-    color?: string;
-}
-interface PasswordInputWithStrengthProps extends PasswordProps {
-    showStrengthIndicator?: boolean;
-}
-
-/**
- * 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",
-    RELOAD = "reload"
-}
-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.NONE;
-        };
-        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.RELOAD;
-        };
-        readonly "auth.logged_out": {
-            readonly action: NavigationAction.RELOAD;
-        };
-        readonly "auth.email_verified": {
-            readonly action: NavigationAction.RELOAD;
-        };
-        readonly "auth.signin_required_modal": {
-            readonly action: NavigationAction.NONE;
-        };
-    };
-    readonly "/": {
-        readonly "auth.logged_in": {
-            readonly action: NavigationAction.NONE;
-        };
-        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;
-        };
-    };
-};
-
-/**
- * Middleware request context containing all necessary data
- */
-interface MiddlewareContext {
-    request: NextRequest;
-    method: string;
-    pathname: string;
-    searchParams: URLSearchParams;
-    cookies: NextRequest['cookies'];
-    nextUrl: URL;
-    hostname: string;
-}
-/**
- * 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;
-declare const getTermsCheckboxField: (options?: CheckboxProps) => BaseFormField;
-declare const getForgotPasswordField: (options?: ButtonProps) => BaseFormField;
-
-/**
- * Middleware configuration constants for routing and protection
- */
-declare class MiddlewareConfig {
-    static readonly CONSTANTS: {
-        readonly LOGIN_PATH: "/login";
-        readonly DASHBOARD_SUBDOMAIN: "dashboard";
-        readonly PUBLIC_PATH: "/public";
-        readonly PUBLIC_API_PATH: "/api/public";
-    };
-    /**
-     * Get public routes whitelist from environment variable
-     * Expected format: comma-separated paths like "/public,/links/new,/about"
-     */
-    static getPublicRoutesWhitelist(): string[];
-    static readonly PROTECTED_ROUTES: {
-        INCLUDE: string[];
-        EXCLUDE: string[];
-    };
-    static readonly ALLOWED_METHODS: readonly ["GET", "HEAD"];
-    static readonly QUERY_PARAMS: {
-        readonly LOGIN_REQUIRED: "sign_in_required";
-        readonly AUTH_CHECKED: "auth_checked";
-        readonly REDIRECT_URL: "redirect_url";
-    };
-    static readonly QUERY_VALUES: {
-        readonly LOGIN_REQUIRED: "true";
-        readonly AUTH_CHECKED: "1";
-    };
-    /**
-     * Get the base domain from environment or use default
-     */
-    static getBaseDomain(): string;
-    /**
-     * Get the protocol based on environment
-     */
-    static getProtocol(): string;
-}
-/**
- * Middleware matcher patterns
- * Matches all routes except API routes, Next.js internals, and static assets
- */
-declare const middlewareMatcher: readonly ["/((?!api|_next/static|_next/image|_next/webpack-hmr|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp|ico|css|js)$).*)"];
-/**
- * Middleware configuration
- */
-declare const config: {
-    matcher: readonly ["/((?!api|_next/static|_next/image|_next/webpack-hmr|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp|ico|css|js)$).*)"];
-};
-
 /**
  * Cookie utility for managing authentication tokens with automatic SSR and client-side support
  * Automatically chooses the right method based on environment
@@ -848,6 +325,10 @@ declare class LocalStorageUtils {
     static isCacheValid(cacheDuration?: number): boolean;
 }
 
+declare enum Channel {
+    AUTH = "auth-event-channel"
+}
+
 type Handler<T> = (e: T) => void;
 declare class BroadcastChannelEventBus<TEvent> {
     private channel?;
@@ -904,433 +385,1026 @@ declare class CrossTabBehaviorHandler {
 }
 
 /**
- * URL utility functions
+ * URL utility functions
+ */
+declare class UrlUtils {
+    /**
+     * Extract subdomain from hostname
+     * Example: "dashboard.cutly.io" -> "dashboard"
+     */
+    static getSubdomain(hostname: string): string | null;
+    /**
+     * Get root domain for cookie scope
+     * Example: "dashboard.cutly.io" -> ".cutly.io"
+     * Example: "cutly.io" -> ".cutly.io"
+     */
+    static getRootDomain(hostname: string): string | null;
+    /**
+     * Check if URL has auth-related query parameters
+     */
+    static hasAuthParams(url: string): boolean;
+    /**
+     * Get the dashboard URL for the current environment
+     */
+    static getDashboardUrl(location: Pick<Location, 'protocol' | 'hostname'>): string;
+}
+
+declare class EmailProviderUtils {
+    /**
+     * Detects email provider from email address
+     */
+    static detectProvider(email: string): EmailProviderConfig | null;
+    /**
+     * Generates inbox URL for the given email
+     */
+    static getInboxUrl(email: string, subject?: string): string | null;
+    /**
+     * Gets provider name from email
+     */
+    static getProviderName(email: string): string | null;
+}
+
+/**
+ * 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 UrlUtils {
+declare class AuthService extends BaseService implements IAuthService {
     /**
-     * Extract subdomain from hostname
-     * Example: "dashboard.cutly.io" -> "dashboard"
+     * Check if an email exists in the system
      */
-    static getSubdomain(hostname: string): string | null;
+    checkEmailExists(email: string): Promise<EmailExistResponse>;
     /**
-     * Get root domain for cookie scope
-     * Example: "dashboard.cutly.io" -> ".cutly.io"
-     * Example: "cutly.io" -> ".cutly.io"
+     * Login with email and password
      */
-    static getRootDomain(hostname: string): string | null;
+    login(credentials: LoginRequest): Promise<LoginResponse>;
     /**
-     * Check if URL has auth-related query parameters
+     * Login with Google
      */
-    static hasAuthParams(url: string): boolean;
+    loginWithGoogle(token: string): Promise<LoginResponse>;
     /**
-     * Get the dashboard URL for the current environment
+     * Verify email with verification code
      */
-    static getDashboardUrl(location: Pick<Location, 'protocol' | 'hostname'>): string;
-}
-
-/**
- * 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>;
+    verifyEmail(verification: VerifyEmailRequest): Promise<VerifyEmailResponse>;
     /**
-     * Get all stored tokens for debugging or validation
+     * Get user profile
      */
-    getAllTokens(): Promise<Record<string, string>>;
+    getUserProfile(): Promise<UserProfileResponse>;
     /**
-     * Check if cookies are supported in the current environment
+     * Get public user profile (me)
      */
-    areCookiesSupported(): boolean;
+    getMe(): Promise<PublicUserProfileResponse>;
     /**
-     * Get domain information for debugging
+     * Logout user
      */
-    getDomainInfo(): Record<string, string>;
+    logout(): Promise<void>;
 }
 
 /**
- * HTTP Client with better error handling
+ * Authentication API endpoints
  */
-declare class HttpClient {
-    private config;
-    constructor(config: HttpClientConfig);
+declare const AUTH_ENDPOINTS: {
+    readonly CHECK_EMAIL_EXISTS: (email: string) => string;
+    readonly LOGIN: "/auth/user/login";
+    readonly LOGIN_GOOGLE: "/auth/user/login/google";
+    readonly VERIFY_EMAIL: "/auth/user/verify";
+    readonly GET_USER_PROFILE: "/auth/user/profile";
+    readonly GET_ME: "/auth/user/me";
+    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 LOGIN_GOOGLE: "/auth/user/login/google";
+        readonly VERIFY_EMAIL: "/auth/user/verify";
+        readonly GET_USER_PROFILE: "/auth/user/profile";
+        readonly GET_ME: "/auth/user/me";
+        readonly LOGOUT: "/auth/logout";
+    };
+}
+
+/**
+ * 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 Verification Strategy
+ * Handles the case when user needs to verify their email before logging in
+ * API returns next_action: "login-verification"
+ */
+declare class LoginVerificationStrategy implements ILoginFlowStrategy {
+    private authService;
+    private tokenManager;
+    constructor(authService: AuthService, tokenManager: ITokenManager);
+    execute(credentials: LoginRequest): Promise<AuthActionResult<LoginData>>;
+}
+
+/**
+ * Strategy Pattern: Login Flow Strategy Factory
+ */
+declare class LoginFlowStrategyFactory {
+    private static strategies;
+    static createStrategy(action: NextAction, authService: AuthService, tokenManager: ITokenManager): ILoginFlowStrategy;
+}
+
+/**
+ * Strategy Pattern: Login Strategy Resolution
+ * Uses Command Pattern to eliminate conditionals
+ */
+/**
+ * Enum: Strategy resolution modes
+ * Easily extendable for new resolution strategies
+ */
+declare enum StrategyResolutionMode {
+    SKIP_EMAIL_CHECK = "SKIP_EMAIL_CHECK",
+    CHECK_EMAIL_EXISTS = "CHECK_EMAIL_EXISTS"
+}
+interface IStrategyCommand {
+    execute(email: string): Promise<NextAction>;
+}
+/**
+ * Strategy Resolver: Eliminates conditionals using Command Pattern
+ * Easy to extend with new strategies without modifying existing code
+ */
+declare class LoginStrategyResolver {
+    private readonly strategies;
+    constructor(authService: AuthService);
+    resolve(email: string, mode: StrategyResolutionMode): Promise<NextAction>;
     /**
-     * Execute HTTP request
+     * Extend resolver with new strategies at runtime
+     * Example: resolver.registerStrategy(StrategyResolutionMode.CUSTOM, customCommand)
      */
-    request<T>(endpoint: string, options: HttpRequestOptions): Promise<HttpResponse<T>>;
+    registerStrategy(mode: StrategyResolutionMode, command: IStrategyCommand): void;
+}
+
+/**
+ * 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 {
     /**
-     * Build headers with defaults including multiple API keys and Bearer token
+     * Creates a successful authentication result
      */
-    private buildHeaders;
+    static createSuccess<T = unknown>(data: T): AuthActionResultSuccess<T>;
     /**
-     * Execute request with timeout
+     * Creates a failed authentication result
      */
-    private executeWithTimeout;
+    static createFailure(error?: string | Error | unknown): AuthActionResultFailure;
 }
+
 /**
- * Base Service with dependency injection and better separation of concerns
+ * Chain of Responsibility: Base Error Handler
  */
-declare abstract class BaseService {
-    protected httpClient: HttpClient;
-    protected tokenManager: TokenManager;
-    constructor(httpClient?: HttpClient, tokenManager?: TokenManager);
+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(): 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;
+}
+
+/**
+ * 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;
     /**
-     * Create default HTTP client with configuration
+     * Validate that cookies are supported in the current environment
      */
-    private createDefaultHttpClient;
+    private validateCookieSupport;
     /**
-     * Handle HTTP response and throw structured error if needed
+     * Handle email check to determine if user exists and what action to take
      */
-    private handleResponse;
+    handleEmailCheck(email: string): Promise<AuthActionResult<EmailExistResponse>>;
     /**
-     * Create API error from HTTP response following Single Responsibility Principle
+     * Handle login strategy based on the result of an email check.
+     * This method implements a strategy pattern to decide which login flow to execute.
      */
-    private createApiErrorFromResponse;
+    handleLoginStrategy(loginRequest: LoginRequest): Promise<AuthActionResult<LoginData>>;
     /**
-     * Try to parse API error response from response data
+     * Handle complete login flow with proper error handling and token management
+     * @param credentials - Login credentials (email and password)
+     * @param mode - Strategy resolution mode (defaults to CHECK_EMAIL_EXISTS)
      */
-    private tryParseApiErrorResponse;
+    handleLoginFlow(credentials: LoginRequest, mode?: StrategyResolutionMode): Promise<AuthActionResult<LoginData>>;
     /**
-     * Check if response data has valid API error structure
+     * Handle Google login flow
      */
-    private isValidApiErrorResponse;
+    handleGoogleLogin(token: string): Promise<AuthActionResult<LoginData>>;
     /**
-     * Create generic API error as fallback
+     * Handle email verification flow
      */
-    private createGenericApiError;
+    handleEmailVerification(email: string, code: string): Promise<AuthActionResult>;
     /**
-     * GET request
+     * Handle logout flow
      */
-    protected get<T>(endpoint: string, headers?: Record<string, string>): Promise<T>;
+    handleLogout(): Promise<AuthActionResult>;
     /**
-     * POST request
+     * Check current authentication status using State Pattern
      */
-    protected post<T>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    checkAuthenticationStatus(): Promise<AuthActionResult>;
     /**
-     * PUT request
+     * Get user profile data
      */
-    protected put<T>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    getUserProfileData(): Promise<AuthActionResult>;
     /**
-     * DELETE request
+     * Get public user profile data (me) and save tokens for public sessions
+     *
+     * Note: This method saves tokens but does NOT publish AuthEventType.LoggedIn event,
+     * allowing public sessions to have tokens without being marked as "authenticated".
+     * The store's initializePublicUser() maintains isAuthenticated = false.
      */
-    protected delete<T>(endpoint: string, headers?: Record<string, string>): Promise<T>;
+    getMeData(): Promise<AuthActionResult>;
     /**
-     * PATCH request
+     * Get detailed token information
      */
-    protected patch<T>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    getTokenInfo(): Promise<AuthActionResult>;
 }
-
 /**
- * Authentication Service
- * Handles all authentication-related operations with clean separation of concerns
+ * Authentication Orchestrator Factory
+ * Follows Factory Pattern for dependency injection
  */
-declare class AuthService extends BaseService implements IAuthService {
+declare class AuthOrchestratorFactory {
     /**
-     * Check if an email exists in the system
+     * Create AuthOrchestrator with default dependencies
      */
-    checkEmailExists(email: string): Promise<EmailExistResponse>;
+    static create(): AuthOrchestrator;
     /**
-     * Login with email and password
+     * Create AuthOrchestrator with custom dependencies
      */
-    login(credentials: LoginRequest): Promise<LoginResponse>;
+    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);
     /**
-     * Login with Google
+     * Save user profile data to storage
      */
-    loginWithGoogle(token: string): Promise<LoginResponse>;
+    saveUserProfile(userProfile: UserProfile): boolean;
     /**
-     * Verify email with verification code
+     * Get user profile data from storage
      */
-    verifyEmail(verification: VerifyEmailRequest): Promise<VerifyEmailResponse>;
+    getUserProfile(cacheDuration?: number): UserProfile | null;
     /**
-     * Get user profile
+     * Clear user profile data from storage
      */
-    getUserProfile(): Promise<UserProfileResponse>;
+    clearUserProfile(): boolean;
     /**
-     * Get public user profile (me)
+     * Check if cached user profile is still valid
      */
-    getMe(): Promise<PublicUserProfileResponse>;
+    isCacheValid(cacheDuration?: number): boolean;
     /**
-     * Logout user
+     * Get user profile with automatic cache validation
+     * Returns null if cache is expired or invalid
      */
-    logout(): Promise<void>;
+    getValidUserProfile(cacheDuration?: number): UserProfile | null;
 }
 
 /**
- * Authentication API endpoints
+ * Authentication Orchestrator Interface
+ * Follows Interface Segregation Principle (ISP)
  */
-declare const AUTH_ENDPOINTS: {
-    readonly CHECK_EMAIL_EXISTS: (email: string) => string;
-    readonly LOGIN: "/auth/user/login";
-    readonly LOGIN_GOOGLE: "/auth/user/login/google";
-    readonly VERIFY_EMAIL: "/auth/user/verify";
-    readonly GET_USER_PROFILE: "/auth/user/profile";
-    readonly GET_ME: "/auth/user/me";
-    readonly LOGOUT: "/auth/logout";
+interface IAuthOrchestrator {
+    handleEmailCheck(email: string): Promise<AuthActionResult>;
+    handleLoginFlow(credentials: LoginRequest, mode?: StrategyResolutionMode): Promise<AuthActionResult>;
+    handleGoogleLogin(token: string): Promise<AuthActionResult>;
+    handleEmailVerification(email: string, code: string): Promise<AuthActionResult>;
+    handleLogout(): Promise<AuthActionResult>;
+    checkAuthenticationStatus(): Promise<AuthActionResult>;
+    getUserProfileData(): Promise<AuthActionResult>;
+    getMeData(): 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 FormHeaderProps {
+    title: string;
+    description?: string;
+}
+
+interface BaseFormField extends Omit<FormItemProps, 'children'> {
+    component: React.ReactNode;
+}
+interface FormFieldsProps {
+    fields: BaseFormField[];
+}
+
+interface BaseComponentProps extends FormHeaderProps {
+    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;
+}
+
+interface GoogleSignInActionsProps {
+    onGoogleSignIn?: (token: string) => void;
+    isLoading?: boolean;
+}
+
+interface EmailStepProps extends BaseStepProps, GoogleSignInActionsProps {
+    onSubmit: (email: string) => void | Promise<void>;
+    onForgotPassword?: () => void;
+}
+
+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>;
+    onResendCode?: () => void;
+    codeLength?: number;
+    showResendButton?: boolean;
+}
+
+interface ForgotPasswordStepProps extends BaseStepProps {
+    email: string;
+    onSubmit: (email: string) => void | Promise<void>;
+}
+
+declare enum AuthFlowVariant {
+    DEFAULT = "default",
+    WITH_IMAGE = "with_image"
+}
+type AuthFlowProps = {
+    variant?: AuthFlowVariant;
+    backgroundImage?: string;
 };
-/**
- * Endpoint builder utility
- */
-declare class EndpointBuilder {
-    static auth: {
-        readonly CHECK_EMAIL_EXISTS: (email: string) => string;
-        readonly LOGIN: "/auth/user/login";
-        readonly LOGIN_GOOGLE: "/auth/user/login/google";
-        readonly VERIFY_EMAIL: "/auth/user/verify";
-        readonly GET_USER_PROFILE: "/auth/user/profile";
-        readonly GET_ME: "/auth/user/me";
-        readonly LOGOUT: "/auth/logout";
+type AuthFlowContainerProps = AuthFlowProps;
+type AuthFlowModalProps = AuthFlowProps & {
+    children: ReactNode;
+};
+
+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;
     };
 }
 
-/**
- * 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 Google login flow
-     */
-    handleGoogleLogin(token: string): 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 public user profile data (me) and save tokens for public sessions
-     *
-     * Note: This method saves tokens but does NOT publish AuthEventType.LoggedIn event,
-     * allowing public sessions to have tokens without being marked as "authenticated".
-     * The store's initializePublicUser() maintains isAuthenticated = false.
-     */
-    getMeData(): Promise<AuthActionResult>;
-    /**
-     * Get detailed token information
-     */
-    getTokenInfo(): Promise<AuthActionResult>;
+type StepRegistryBaseProps = Omit<BaseStepProps, 'title' | 'description' | 'submitButtonText'>;
+interface StepRegistryParams {
+    baseProps: StepRegistryBaseProps;
+    handlers: StepRegistryHandlers;
+    state: StepRegistryState;
+    configs: StepRegistryConfigs;
 }
-/**
- * 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;
+interface UseStepRegistryParams extends StepRegistryParams {
+    getStepComponent: (step: AuthFlowStep) => StepComponent | null;
+    stepperState: StepperState;
 }
-
-/**
- * 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;
+interface StepRegistryHandlers {
+    handleEmailSubmit: (email: string) => Promise<void>;
+    handlePasswordSubmit: (password: string) => Promise<void>;
+    handleVerificationSubmit: (code: string) => Promise<void>;
+    handleResendCode: () => void;
+    goBackToEmail: () => void;
+    goBackToPassword: () => void;
+    onGoogleSignIn?: (token: string) => void;
+    handleForgotPassword?: (email: string) => Promise<void>;
+    onForgotPasswordClick?: () => void;
 }
-
-/**
- * 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;
+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 | ForgotPasswordStepProps;
+type StepComponent = React__default.ComponentType<AnyStepProps>;
+type StepRegistry = Record<AuthFlowStep, StepComponent>;
+type PropsFactory = () => AnyStepProps;
+type StepPropsFactoryRegistry = Record<AuthFlowStep, PropsFactory>;
 
-/**
- * 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;
+interface AlertDisplayProps {
+    error?: string;
+    success?: string;
 }
 
-/**
- * Strategy Pattern: Login Flow Strategy Factory
- */
-declare class LoginFlowStrategyFactory {
-    private static strategies;
-    static createStrategy(action: NextAction, authService: AuthService, tokenManager: ITokenManager): ILoginFlowStrategy;
+interface PasswordStrengthRule {
+    label: string;
+    test: (password: string) => boolean;
+}
+interface StrengthResult {
+    label: string;
+    percent: number;
+    status: 'success' | 'exception' | 'normal';
+    color?: string;
+}
+interface PasswordInputWithStrengthProps extends PasswordProps {
+    showStrengthIndicator?: boolean;
 }
 
 /**
- * State Pattern: Authenticated State
+ * Enum for user roles
  */
-declare class AuthenticatedState implements IAuthStatusState {
-    getStatus(tokenManager: ITokenManager): Promise<AuthActionResultSuccess<{
-        isAuthenticated: boolean;
-        hasAccessToken: boolean;
-        hasRefreshToken: boolean;
-        cookiesSupported: boolean;
-        domainInfo: Record<string, string>;
-    }>>;
-    private buildAuthStatus;
+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;
+};
 
 /**
- * State Pattern: Unauthenticated State
+ * Token Management Interface
+ * Follows Single Responsibility Principle (SRP)
+ * Updated to support async operations for SSR compatibility
  */
-declare class UnauthenticatedState implements IAuthStatusState {
-    getStatus(tokenManager: ITokenManager): Promise<AuthActionResultFailure>;
-    private buildAuthStatus;
+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>;
 }
 
 /**
- * State Pattern: Authentication Status Context
+ * Strategy Pattern: Login Flow Strategy Interface
  */
-declare class AuthenticationStatusContext {
-    private static states;
-    static getStatus(tokenManager: ITokenManager): Promise<AuthActionResult>;
+interface ILoginFlowStrategy {
+    execute(credentials: LoginRequest): Promise<AuthActionResult<LoginData>>;
 }
 
 /**
- * Command Pattern: Result Creation Commands
- * Follows Single Responsibility Principle - only responsible for creating AuthResult objects
+ * State Pattern: Authentication Status State Interface
  */
-declare class AuthResultFactory {
-    /**
-     * Creates a successful authentication result
-     */
-    static createSuccess<T = unknown>(data: T): AuthActionResultSuccess<T>;
-    /**
-     * Creates a failed authentication result
-     */
-    static createFailure(error?: string | Error | unknown): AuthActionResultFailure;
+interface IAuthStatusState {
+    getStatus(tokenManager: ITokenManager): Promise<AuthActionResult>;
 }
 
 /**
- * Chain of Responsibility: Base Error Handler
+ * Chain of Responsibility: Error Handler Interface
  */
-declare abstract class BaseErrorHandler implements IErrorHandler {
-    private nextHandler?;
+interface IErrorHandler {
     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
+ * Lookup Pattern: Logger Interface
  */
-declare class ValidationErrorHandler extends BaseErrorHandler {
-    protected canHandle(error: unknown): boolean;
-    protected handleError(error: unknown, context: string): AuthActionResult;
+interface ILogger {
+    log(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
 }
 
-/**
- * Network Error Handler
- */
-declare class NetworkErrorHandler extends BaseErrorHandler {
-    protected canHandle(error: unknown): boolean;
-    protected handleError(error: unknown, context: string): AuthActionResult;
+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",
+    RELOAD = "reload"
 }
+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.NONE;
+        };
+        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.RELOAD;
+        };
+        readonly "auth.logged_out": {
+            readonly action: NavigationAction.RELOAD;
+        };
+        readonly "auth.email_verified": {
+            readonly action: NavigationAction.RELOAD;
+        };
+        readonly "auth.signin_required_modal": {
+            readonly action: NavigationAction.NONE;
+        };
+    };
+    readonly "/": {
+        readonly "auth.logged_in": {
+            readonly action: NavigationAction.NONE;
+        };
+        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;
+        };
+    };
+};
 
 /**
- * Generic Error Handler
+ * Middleware request context containing all necessary data
  */
-declare class GenericErrorHandler extends BaseErrorHandler {
-    protected canHandle(): boolean;
-    protected handleError(error: unknown, context: string): AuthActionResult;
+interface MiddlewareContext {
+    request: NextRequest;
+    method: string;
+    pathname: string;
+    searchParams: URLSearchParams;
+    cookies: NextRequest['cookies'];
+    nextUrl: URL;
+    hostname: string;
 }
-
 /**
- * Development Logger Implementation
+ * Base interface for middleware handlers
  */
-declare class DevelopmentLogger implements ILogger {
-    log(message: string, data?: unknown): void;
-    warn(message: string, data?: unknown): void;
-    error(message: string, data?: unknown): void;
+interface MiddlewareHandler {
+    handle(context: MiddlewareContext): NextResponse | null | Promise<NextResponse | null>;
 }
 
 /**
- * Production Logger Implementation
+ * Email Provider Configuration Interface
+ * Defines the structure for email provider configurations
  */
-declare class ProductionLogger implements ILogger {
-    log(_message: string, _data?: unknown): void;
-    warn(_message: string, _data?: unknown): void;
-    error(_message: string, _data?: unknown): void;
+interface EmailProviderConfig {
+    name: string;
+    pattern: RegExp;
+    getUrl: (email: string, subject?: string) => string;
 }
 
+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.PASSWORD;
+    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, email?: string) => BaseFormField;
+declare const getTermsCheckboxField: (options?: CheckboxProps) => BaseFormField;
+declare const getForgotPasswordField: (options?: ButtonProps) => BaseFormField;
+
 /**
- * Lookup Pattern: Logger Factory with Environment-based Strategy
+ * Middleware configuration constants for routing and protection
  */
-declare class LoggerFactory {
-    private static loggers;
-    static create(environment?: string): ILogger;
+declare class MiddlewareConfig {
+    static readonly CONSTANTS: {
+        readonly LOGIN_PATH: "/login";
+        readonly DASHBOARD_SUBDOMAIN: "dashboard";
+        readonly PUBLIC_PATH: "/public";
+        readonly PUBLIC_API_PATH: "/api/public";
+    };
+    /**
+     * Get public routes whitelist from environment variable
+     * Expected format: comma-separated paths like "/public,/links/new,/about"
+     */
+    static getPublicRoutesWhitelist(): string[];
+    static readonly PROTECTED_ROUTES: {
+        INCLUDE: string[];
+        EXCLUDE: string[];
+    };
+    static readonly ALLOWED_METHODS: readonly ["GET", "HEAD"];
+    static readonly QUERY_PARAMS: {
+        readonly LOGIN_REQUIRED: "sign_in_required";
+        readonly AUTH_CHECKED: "auth_checked";
+        readonly REDIRECT_URL: "redirect_url";
+    };
+    static readonly QUERY_VALUES: {
+        readonly LOGIN_REQUIRED: "true";
+        readonly AUTH_CHECKED: "1";
+    };
+    /**
+     * Get the base domain from environment or use default
+     */
+    static getBaseDomain(): string;
+    /**
+     * Get the protocol based on environment
+     */
+    static getProtocol(): string;
 }
+/**
+ * Middleware matcher patterns
+ * Matches all routes except API routes, Next.js internals, and static assets
+ */
+declare const middlewareMatcher: readonly ["/((?!api|_next/static|_next/image|_next/webpack-hmr|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp|ico|css|js)$).*)"];
+/**
+ * Middleware configuration
+ */
+declare const config: {
+    matcher: readonly ["/((?!api|_next/static|_next/image|_next/webpack-hmr|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp|ico|css|js)$).*)"];
+};
 
 /**
  * User store state interface
@@ -1648,4 +1722,4 @@ declare const useAuthFlowModal: () => {
     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, type AuthFlowContainerProps, AuthFlowModal, type AuthFlowModalProps, type AuthFlowProps, AuthFlowStep, AuthFlowVariant, 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, type ForgotPasswordStepProps, 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, PasswordInputWithStrength, type PasswordInputWithStrengthProps, PasswordStep, type PasswordStepProps, type PasswordStrengthRule, ProductionLogger, ProfileStateRenderer, ProfileUIState, type PropsFactory, type PublicUserProfile, type PublicUserProfileResponse, 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 StrengthResult, type Subscription, TokenManager, UnauthenticatedState, UrlUtils, 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, getForgotPasswordField, getPasswordField, getStepForEmailSubmission, getStepForPasswordSubmission, getStepForVerificationSubmission, getStepProgressMessage, getTermsCheckboxField, getVerificationField, isPublicUser, isPublicUserEmail, middlewareMatcher, useAuth, useAuthActionHandler, useAuthEventBus, useAuthFlowModal, useAuthInitializer, useIsAuthenticated, useLogout, usePublicUserSession, useRefreshUser, useSharedEventBus, useSignInRequiredParams, useStepRegistry, useStepRenderer, useStepper, useUser, useUserActions, useUserData, useUserError, useUserLoading, useUserProfile, useUserSelectors, useUserStore, userSelectors };
+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, type AuthFlowContainerProps, AuthFlowModal, type AuthFlowModalProps, type AuthFlowProps, AuthFlowStep, AuthFlowVariant, 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, type EmailProviderConfig, EmailProviderUtils, EmailStep, type EmailStepProps, EndpointBuilder, type EventBus, ExistingUserLoginStrategy, type ForgotPasswordStepProps, 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, LoginStrategyResolver, LoginVerificationStrategy, MiddlewareConfig, type MiddlewareContext, type MiddlewareHandler, NavigationAction, NetworkErrorHandler, NextAction, PASSWORD_SUBMISSION_NAVIGATION, PageType, PageTypePatterns, PasswordInputWithStrength, type PasswordInputWithStrengthProps, PasswordStep, type PasswordStepProps, type PasswordStrengthRule, ProductionLogger, ProfileStateRenderer, ProfileUIState, type PropsFactory, type PublicUserProfile, type PublicUserProfileResponse, 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, StrategyResolutionMode, type StrengthResult, type Subscription, TokenManager, UnauthenticatedState, UrlUtils, 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, getForgotPasswordField, getPasswordField, getStepForEmailSubmission, getStepForPasswordSubmission, getStepForVerificationSubmission, getStepProgressMessage, getTermsCheckboxField, getVerificationField, isPublicUser, isPublicUserEmail, middlewareMatcher, useAuth, useAuthActionHandler, useAuthEventBus, useAuthFlowModal, useAuthInitializer, useIsAuthenticated, useLogout, usePublicUserSession, useRefreshUser, useSharedEventBus, useSignInRequiredParams, useStepRegistry, useStepRenderer, useStepper, useUser, useUserActions, useUserData, useUserError, useUserLoading, useUserProfile, useUserSelectors, useUserStore, userSelectors };