import * as react_jsx_runtime from 'react/jsx-runtime';
import React from 'react';

interface AuthUser {
    id: string;
    email?: string;
    username?: string;
    [key: string]: unknown;
}
/** Best display label for a user: email, then username, then id. */
declare function userLabel(u: AuthUser | null | undefined): string;
type AuthStatus = "checking" | "authed" | "guest";
interface AuthState {
    status: AuthStatus;
    user: AuthUser | null;
}
interface AuthContextValue extends AuthState {
    /** Identifier field in use ("email" | "username") — drives input type/labels. */
    usernameField: string;
    /** Re-read the session (`GET {basePath}/me`) and update state. */
    refresh: () => Promise<void>;
    /** Resolves to null on success, or an error message on failure. */
    signIn: (email: string, password: string) => Promise<string | null>;
    signUp: (email: string, password: string) => Promise<string | null>;
    signOut: () => Promise<void>;
    changePassword: (currentPassword: string, newPassword: string) => Promise<string | null>;
}
/** Endpoint configuration shared by the provider and the bare api helpers. */
interface AuthApiConfig {
    /** Base path the route handlers live under. Default "/api/auth". */
    basePath?: string;
}

declare function AuthProvider({ children, basePath, usernameField, }: {
    children: React.ReactNode;
    /** Where the auth route handlers live. Same-origin by default. */
    basePath?: string;
    /** Identifier field posted on login/register. "email" (default) or "username". */
    usernameField?: string;
}): react_jsx_runtime.JSX.Element;
declare function useAuth(): AuthContextValue;

interface AuthBarProps {
    basePath?: string;
    /** Identifier field for login/register. "email" (default) or "username". */
    usernameField?: string;
    /** Called after any auth change (sign-in/up/out) — e.g. router.refresh(). */
    onAuthChange?: () => void;
}
/**
 * Drop-in auth widget for a page header. Carries its own <AuthProvider>, so it
 * works anywhere — including inside server components — with no app-wide setup.
 */
declare const AuthBar: React.FC<AuthBarProps>;

interface RequireAuthProps {
    /** Shown while the session check is in flight. */
    fallback?: React.ReactNode;
    /** Rendered for guests. Provide your own router redirect here. */
    guest: React.ReactNode;
    children: React.ReactNode;
}
/**
 * Cookie-session route guard. Unlike a synchronous token check, the session is
 * verified async via the provider, so render `fallback` while `checking`.
 *
 * Router-agnostic: pass your framework's redirect as `guest`, e.g.
 *   <RequireAuth guest={<Navigate to="/login" replace />}>...</RequireAuth>
 */
declare const RequireAuth: React.FC<RequireAuthProps>;

interface LoginProps {
    /** Called after a successful sign-in. */
    onSuccess?: () => void;
    submitLabel?: string;
}
/**
 * Headless email/password sign-in form. Must be rendered inside an
 * <AuthProvider>. No router, no MUI — bring your own page/layout.
 */
declare const Login: React.FC<LoginProps>;

interface RegisterProps {
    onSuccess?: () => void;
    submitLabel?: string;
    /** Minimum password length enforced client-side. Default 6. */
    minPasswordLength?: number;
}
/** Headless email/password registration form. Render inside <AuthProvider>. */
declare const Register: React.FC<RegisterProps>;

declare const AbstractRegister: React.FC<RegisterProps>;

interface LogoutButtonProps {
    onSuccess?: () => void;
    label?: string;
    style?: React.CSSProperties;
}
/** Headless logout button. Render inside <AuthProvider>. */
declare const Logout: React.FC<LogoutButtonProps>;

declare const AbstractLogout: React.FC<LogoutButtonProps>;

interface ChangePasswordProps {
    onSuccess?: () => void;
    submitLabel?: string;
    minPasswordLength?: number;
}
/** Headless change-password form. Render inside <AuthProvider> when signed in. */
declare const ChangePassword: React.FC<ChangePasswordProps>;

declare const AbstractChangePassword: React.FC<ChangePasswordProps>;

declare function fetchMe(basePath?: string): Promise<{
    id: string;
    email?: string;
    [k: string]: unknown;
} | null>;
/** Sign in. Returns null on success, else an error message. */
declare function loginWithAbstract(identifier: string, password: string, basePath?: string, usernameField?: string): Promise<string | null>;
/** Register. Returns null on success, else an error message. */
declare function registerWithAbstract(identifier: string, password: string, basePath?: string, usernameField?: string): Promise<string | null>;
/** Sign out. Best-effort; never throws. */
declare function logoutUser(basePath?: string): Promise<void>;
/** Change password (must be signed in). Returns null on success, else error. */
declare function changePassword(currentPassword: string, newPassword: string, basePath?: string): Promise<string | null>;

export { AbstractChangePassword, AbstractLogout, AbstractRegister, AuthBar, AuthProvider, ChangePassword, Login, Logout, Register, RequireAuth, changePassword, fetchMe, loginWithAbstract, logoutUser, registerWithAbstract, useAuth, userLabel };
export type { AuthApiConfig, AuthBarProps, AuthContextValue, AuthState, AuthStatus, AuthUser, ChangePasswordProps, LoginProps, LogoutButtonProps, RegisterProps, RequireAuthProps };