/**
 * Session Management
 *
 * Token refresh and session lifecycle management.
 * Auto-refresh ensures continuous authentication without user interruption.
 *
 * @packageDocumentation
 */
import { SESSION_CONFIG, type TokenResponse, type JWTPayload, type User, type SessionState, type RefreshResult, type SessionAnalyticsEvent, type SessionManagerOptions, type AuthHooksConfig, type JWK } from './types.js';
export { SESSION_CONFIG };
export type { TokenResponse, JWTPayload, User, SessionState, RefreshResult, SessionAnalyticsEvent, SessionManagerOptions, AuthHooksConfig, JWK, };
/**
 * Decode a JWT without verification (for client-side use only)
 * Use validateToken() for server-side verification
 */
export declare function decodeJWT(token: string): JWTPayload | null;
/**
 * Check if a token is expired or about to expire
 */
export declare function isTokenExpired(token: string, thresholdSeconds?: number): boolean;
/**
 * Check if token needs refresh (within threshold of expiration)
 */
export declare function needsRefresh(token: string): boolean;
/**
 * Get time until token expires in seconds
 */
export declare function getTokenTTL(token: string): number;
/**
 * Extract user info from access token
 */
export declare function getUserFromToken(token: string): User | null;
/**
 * Refresh tokens using the Identity worker
 *
 * @example
 * ```typescript
 * // In +page.server.ts
 * const session = getSessionCookies(cookies);
 * if (session.refreshToken && needsRefresh(session.accessToken)) {
 *   const result = await refreshTokens(session.refreshToken);
 *   if (result.success) {
 *     setSessionCookies(cookies, {
 *       accessToken: result.tokens.access_token,
 *       refreshToken: result.tokens.refresh_token,
 *     });
 *   }
 * }
 * ```
 */
export declare function refreshTokens(refreshToken: string): Promise<RefreshResult>;
/**
 * Logout by revoking refresh token at Identity worker
 */
export declare function revokeSession(refreshToken: string): Promise<boolean>;
/**
 * Minimal cookies interface compatible with SvelteKit's Cookies
 * Uses a permissive function signature to accept various cookie implementations
 */
export type CookiesAPI = {
    get: (name: string) => string | undefined;
    set: (name: string, value: string, options: any) => void;
    delete: (name: string, options?: any) => void;
};
/**
 * Create a session manager for server-side use
 *
 * @example
 * ```typescript
 * // In +layout.server.ts
 * import { createSessionManager } from '@create-something/components/auth';
 *
 * export const load = async ({ cookies, platform }) => {
 *   const session = createSessionManager(cookies, {
 *     isProduction: platform?.env.ENVIRONMENT === 'production',
 *     onAnalyticsEvent: (event) => {
 *       // Send to analytics
 *     }
 *   });
 *
 *   const user = await session.getUser();
 *   return { user };
 * };
 * ```
 */
export declare function createSessionManager(cookies: CookiesAPI, options?: SessionManagerOptions): {
    /**
     * Get current user from session, refreshing if needed
     */
    getUser(): Promise<User | null>;
    /**
     * Get session state with expiration info
     */
    getState(): SessionState;
    /**
     * Check if tokens need refresh
     */
    needsRefresh(): boolean;
    /**
     * Refresh tokens if needed, returns true if successful
     */
    refresh(): Promise<boolean>;
    /**
     * Set tokens after login
     */
    setTokens(tokens: TokenResponse): void;
    /**
     * Clear session (logout)
     */
    logout(): Promise<void>;
};
/**
 * Auto-refresh middleware for SvelteKit hooks
 *
 * @example
 * ```typescript
 * // In hooks.server.ts
 * import { autoRefreshMiddleware } from '@create-something/components/auth';
 *
 * export const handle: Handle = async ({ event, resolve }) => {
 *   await autoRefreshMiddleware(event.cookies);
 *   return resolve(event);
 * };
 * ```
 */
export declare function autoRefreshMiddleware(cookies: CookiesAPI, options?: SessionManagerOptions): Promise<boolean>;
/**
 * Require authentication, redirect if not authenticated
 *
 * @example
 * ```typescript
 * // In +page.server.ts
 * import { requireAuth } from '@create-something/components/auth';
 * import { redirect } from '@sveltejs/kit';
 *
 * export const load = async ({ cookies }) => {
 *   const user = await requireAuth(cookies);
 *   if (!user) {
 *     throw redirect(303, '/login');
 *   }
 *   return { user };
 * };
 * ```
 */
export declare function requireAuth(cookies: CookiesAPI, options?: SessionManagerOptions): Promise<User | null>;
/** SvelteKit Handle function type */
type Handle = (input: {
    event: {
        cookies: CookiesAPI;
        url: URL;
        locals: {
            user?: User | null;
        };
    };
    resolve: (event: unknown) => Promise<Response>;
}) => Promise<Response>;
/**
 * Create SvelteKit auth hooks with auto-refresh and protected routes
 *
 * @example
 * ```typescript
 * // In hooks.server.ts
 * import { createAuthHooks } from '@create-something/components/auth';
 *
 * export const handle = createAuthHooks({
 *   protectedPaths: ['/dashboard', '/settings', '/account'],
 *   loginPath: '/login',
 * });
 * ```
 *
 * @example
 * ```typescript
 * // Custom composition with other hooks
 * import { sequence } from '@sveltejs/kit/hooks';
 * import { createAuthHooks } from '@create-something/components/auth';
 *
 * const authHooks = createAuthHooks({ protectedPaths: ['/app'] });
 *
 * export const handle = sequence(
 *   authHooks,
 *   customLoggingHook
 * );
 * ```
 */
export declare function createAuthHooks(config?: AuthHooksConfig): Handle;
/**
 * Handle logout request - revoke session and clear cookies
 *
 * Consolidates logout logic across all CREATE SOMETHING properties.
 * Determines domain from request URL to set cross-subdomain cookies.
 *
 * @param request - The incoming request
 * @param cookies - SvelteKit cookies API
 * @param platform - Cloudflare platform object (for environment detection)
 * @returns JSON response with success/error status
 *
 * @example
 * ```typescript
 * // In +server.ts
 * import { handleLogout } from '@create-something/components/auth';
 * import type { RequestHandler } from './$types';
 *
 * export const POST: RequestHandler = async ({ request, cookies, platform }) => {
 *   return handleLogout(request, cookies, platform);
 * };
 * ```
 */
export declare function handleLogout(request: Request, cookies: CookiesAPI, platform?: {
    env?: {
        ENVIRONMENT?: string;
    };
}): Promise<Response>;