unologin-nextjs 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# unologin-nextjs
+
+Clerk-like MVP toolkit for integrating UnoLogin into Next.js App Router:
+
+- server helpers for OAuth callback/session cookies;
+- route handler factory (`sign-in`, `callback`, `sign-out`, `session`);
+- React provider/hooks (`UnoLoginProvider`, `useAuth`, `useUser`);
+- ready components (`SignIn`, `UserButton`, `UserProfile`);
+- middleware helper for protected routes.
+
+See full guide in `docs/NEXTJS.md`.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './server';
+export * from './react';
+export * from './middleware';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './server';
+export * from './react';
+export * from './middleware';

package/dist/middleware/index.d.ts

@@ -0,0 +1,8 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+export interface AuthMiddlewareOptions {
+    signInPath?: string;
+    publicPaths?: string[];
+    sessionCookieName?: string;
+}
+export declare function createAuthMiddleware(options?: AuthMiddlewareOptions): (request: NextRequest) => NextResponse;

package/dist/middleware/index.js

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server';
+const DEFAULT_SESSION_COOKIE = '__unologin_session';
+function pathMatches(pathname, path) {
+    return pathname === path || pathname.startsWith(`${path}/`);
+}
+export function createAuthMiddleware(options = {}) {
+    const signInPath = options.signInPath ?? '/auth';
+    const publicPaths = new Set(options.publicPaths ?? [signInPath, '/api/auth/callback', '/api/auth/sign-in']);
+    const sessionCookieName = options.sessionCookieName ?? DEFAULT_SESSION_COOKIE;
+    return function authMiddleware(request) {
+        const { pathname, search } = request.nextUrl;
+        if (Array.from(publicPaths).some((path) => pathMatches(pathname, path))) {
+            return NextResponse.next();
+        }
+        const hasSession = Boolean(request.cookies.get(sessionCookieName)?.value);
+        if (hasSession) {
+            return NextResponse.next();
+        }
+        // Prevent redirect loops if the current route is already auth-adjacent.
+        if (pathname.startsWith('/api/auth')) {
+            return NextResponse.next();
+        }
+        const redirectTo = `${pathname}${search}`;
+        const target = new URL('/api/auth/sign-in', request.url);
+        target.searchParams.set('redirect_to', redirectTo);
+        return NextResponse.redirect(target);
+    };
+}

package/dist/packages/nextjs/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './server';
+export * from './react';
+export * from './middleware';

package/dist/packages/nextjs/src/index.js

@@ -0,0 +1,3 @@
+export * from './server';
+export * from './react';
+export * from './middleware';

package/dist/packages/nextjs/src/middleware/index.d.ts

@@ -0,0 +1,8 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+export interface AuthMiddlewareOptions {
+    signInPath?: string;
+    publicPaths?: string[];
+    sessionCookieName?: string;
+}
+export declare function createAuthMiddleware(options?: AuthMiddlewareOptions): (request: NextRequest) => NextResponse;

package/dist/packages/nextjs/src/middleware/index.js

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server';
+const DEFAULT_SESSION_COOKIE = '__unologin_session';
+function pathMatches(pathname, path) {
+    return pathname === path || pathname.startsWith(`${path}/`);
+}
+export function createAuthMiddleware(options = {}) {
+    const signInPath = options.signInPath ?? '/auth';
+    const publicPaths = new Set(options.publicPaths ?? [signInPath, '/api/auth/callback', '/api/auth/sign-in']);
+    const sessionCookieName = options.sessionCookieName ?? DEFAULT_SESSION_COOKIE;
+    return function authMiddleware(request) {
+        const { pathname, search } = request.nextUrl;
+        if (Array.from(publicPaths).some((path) => pathMatches(pathname, path))) {
+            return NextResponse.next();
+        }
+        const hasSession = Boolean(request.cookies.get(sessionCookieName)?.value);
+        if (hasSession) {
+            return NextResponse.next();
+        }
+        // Prevent redirect loops if the current route is already auth-adjacent.
+        if (pathname.startsWith('/api/auth')) {
+            return NextResponse.next();
+        }
+        const redirectTo = `${pathname}${search}`;
+        const target = new URL('/api/auth/sign-in', request.url);
+        target.searchParams.set('redirect_to', redirectTo);
+        return NextResponse.redirect(target);
+    };
+}

package/dist/packages/nextjs/src/react/SignIn.d.ts

@@ -0,0 +1,18 @@
+declare global {
+    interface Window {
+        UnoLoginWidgetV2?: {
+            mount: (config: Record<string, unknown>) => void;
+            unmount: () => void;
+        };
+    }
+}
+export interface SignInProps {
+    clientId: string;
+    redirectUri: string;
+    unoLoginUrl: string;
+    enabledMethods?: string[];
+    locale?: 'ru' | 'en';
+    theme?: 'light' | 'dark' | 'system';
+    debug?: boolean;
+}
+export declare function SignIn({ clientId, redirectUri, unoLoginUrl, enabledMethods, locale, theme, debug, }: SignInProps): import("react/jsx-runtime").JSX.Element;

package/dist/packages/nextjs/src/react/SignIn.js

@@ -0,0 +1,76 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+function loadScript(src) {
+    return new Promise((resolve, reject) => {
+        const existing = document.querySelector(`script[data-unologin-widget-src="${src}"]`);
+        if (existing) {
+            if (window.UnoLoginWidgetV2) {
+                resolve();
+            }
+            else {
+                existing.addEventListener('load', () => resolve(), { once: true });
+                existing.addEventListener('error', () => reject(new Error('Failed to load UnoLogin widget')), {
+                    once: true,
+                });
+            }
+            return;
+        }
+        const script = document.createElement('script');
+        script.src = src;
+        script.async = true;
+        script.dataset.unologinWidgetSrc = src;
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error('Failed to load UnoLogin widget'));
+        document.head.appendChild(script);
+    });
+}
+export function SignIn({ clientId, redirectUri, unoLoginUrl, enabledMethods = ['vk', 'yandex', 'google', 'password', 'webauthn'], locale = 'ru', theme = 'light', debug = false, }) {
+    const containerRef = useRef(null);
+    const [error, setError] = useState(null);
+    const loginRequired = useMemo(() => {
+        if (typeof window === 'undefined') {
+            return false;
+        }
+        return new URLSearchParams(window.location.search).get('error') === 'login_required';
+    }, []);
+    useEffect(() => {
+        const scriptUrl = `${unoLoginUrl.replace(/\/$/, '')}/widget/v2.js`;
+        let mounted = false;
+        loadScript(scriptUrl)
+            .then(() => {
+            if (!containerRef.current || !window.UnoLoginWidgetV2 || mounted) {
+                return;
+            }
+            window.UnoLoginWidgetV2.mount({
+                container: containerRef.current,
+                clientId,
+                redirectUri,
+                enabledMethods,
+                locale,
+                theme,
+                debug,
+                onError: (payload) => {
+                    setError(payload?.message ?? 'Sign-in error');
+                },
+                onOAuthRedirect: (payload) => {
+                    if (!payload?.url) {
+                        setError('OAuth redirect URL is missing');
+                        return;
+                    }
+                    window.location.href = payload.url;
+                },
+            });
+            mounted = true;
+        })
+            .catch((e) => {
+            setError(e instanceof Error ? e.message : 'Failed to load widget');
+        });
+        return () => {
+            if (window.UnoLoginWidgetV2 && mounted) {
+                window.UnoLoginWidgetV2.unmount();
+            }
+        };
+    }, [clientId, redirectUri, unoLoginUrl, enabledMethods, locale, theme, debug]);
+    return (_jsxs("div", { children: [loginRequired ? (_jsx("p", { style: { marginBottom: 12 }, children: "SSO session was not found. Please sign in with any available method." })) : null, error ? (_jsx("p", { role: "alert", style: { color: '#dc2626', marginBottom: 12 }, children: error })) : null, _jsx("div", { ref: containerRef })] }));
+}

package/dist/packages/nextjs/src/react/UserButton.d.ts

@@ -0,0 +1,4 @@
+export interface UserButtonProps {
+    signOutUrl?: string;
+}
+export declare function UserButton({ signOutUrl }: UserButtonProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/packages/nextjs/src/react/UserButton.js

@@ -0,0 +1,23 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { useAuth } from './context';
+export function UserButton({ signOutUrl = '/api/auth/sign-out' }) {
+    const { user, isAuthenticated, refresh } = useAuth();
+    const [isBusy, setBusy] = useState(false);
+    if (!isAuthenticated || !user) {
+        return null;
+    }
+    const displayName = user.firstName || user.username || user.email || user.sub;
+    return (_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 8 }, children: [_jsx("span", { children: displayName }), _jsx("button", { type: "button", disabled: isBusy, onClick: async () => {
+                    setBusy(true);
+                    try {
+                        await fetch(signOutUrl, { method: 'POST', credentials: 'include' });
+                        await refresh();
+                        window.location.href = '/';
+                    }
+                    finally {
+                        setBusy(false);
+                    }
+                }, children: isBusy ? 'Signing out...' : 'Sign out' })] }));
+}

package/dist/packages/nextjs/src/react/UserProfile.d.ts

@@ -0,0 +1 @@
+export declare function UserProfile(): import("react/jsx-runtime").JSX.Element;

package/dist/packages/nextjs/src/react/UserProfile.js

@@ -0,0 +1,13 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useAuth } from './context';
+export function UserProfile() {
+    const { isLoaded, isAuthenticated, user } = useAuth();
+    if (!isLoaded) {
+        return _jsx("p", { children: "Loading profile..." });
+    }
+    if (!isAuthenticated || !user) {
+        return _jsx("p", { children: "Please sign in to view your profile." });
+    }
+    return (_jsxs("section", { style: { display: 'grid', gap: 8 }, children: [_jsx("h2", { style: { margin: 0 }, children: "User Profile" }), _jsxs("div", { children: [_jsx("strong", { children: "ID:" }), " ", user.sub] }), user.email ? (_jsxs("div", { children: [_jsx("strong", { children: "Email:" }), " ", user.email] })) : null, user.username ? (_jsxs("div", { children: [_jsx("strong", { children: "Username:" }), " ", user.username] })) : null, user.role ? (_jsxs("div", { children: [_jsx("strong", { children: "Role:" }), " ", user.role] })) : null, user.organization ? (_jsxs("div", { children: [_jsx("strong", { children: "Organization:" }), " ", user.organization.companyName, " (", user.organization.inn, ")"] })) : null] }));
+}

package/dist/packages/nextjs/src/react/context.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import type { AuthState } from './types';
+interface UnoLoginProviderProps {
+    children: ReactNode;
+    sessionEndpoint?: string;
+}
+export declare function UnoLoginProvider({ children, sessionEndpoint }: UnoLoginProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAuth(): AuthState;
+export declare function useUser(): import("..").UnoLoginUser | null;
+export {};

package/dist/packages/nextjs/src/react/context.js

@@ -0,0 +1,53 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+const AuthContext = createContext(null);
+export function UnoLoginProvider({ children, sessionEndpoint = '/api/auth/session' }) {
+    const [isLoaded, setLoaded] = useState(false);
+    const [isAuthenticated, setAuthenticated] = useState(false);
+    const [user, setUser] = useState(null);
+    const refresh = useCallback(async () => {
+        try {
+            const response = await fetch(sessionEndpoint, {
+                method: 'GET',
+                credentials: 'include',
+                cache: 'no-store',
+            });
+            if (!response.ok) {
+                setAuthenticated(false);
+                setUser(null);
+                return;
+            }
+            const payload = (await response.json());
+            setAuthenticated(payload.authenticated);
+            setUser(payload.user ?? null);
+        }
+        catch {
+            setAuthenticated(false);
+            setUser(null);
+        }
+        finally {
+            setLoaded(true);
+        }
+    }, [sessionEndpoint]);
+    useEffect(() => {
+        refresh().catch(() => undefined);
+    }, [refresh]);
+    const value = useMemo(() => ({
+        isLoaded,
+        isAuthenticated,
+        user,
+        refresh,
+    }), [isLoaded, isAuthenticated, user, refresh]);
+    return _jsx(AuthContext.Provider, { value: value, children: children });
+}
+export function useAuth() {
+    const context = useContext(AuthContext);
+    if (!context) {
+        throw new Error('useAuth must be used inside UnoLoginProvider');
+    }
+    return context;
+}
+export function useUser() {
+    return useAuth().user;
+}

package/dist/packages/nextjs/src/react/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './context';
+export * from './SignIn';
+export * from './UserButton';
+export * from './UserProfile';

package/dist/packages/nextjs/src/react/index.js

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './context';
+export * from './SignIn';
+export * from './UserButton';
+export * from './UserProfile';

package/dist/packages/nextjs/src/react/types.d.ts

@@ -0,0 +1,7 @@
+import type { UnoLoginUser } from '../server';
+export interface AuthState {
+    isLoaded: boolean;
+    isAuthenticated: boolean;
+    user: UnoLoginUser | null;
+    refresh: () => Promise<void>;
+}

package/dist/packages/nextjs/src/react/types.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/nextjs/src/server/client.d.ts

@@ -0,0 +1,32 @@
+import type { SignInUrlOptions, UnoLoginNextServerConfig, UnoLoginSession } from './types';
+interface CallbackResponseSuccess {
+    ok: true;
+    session: UnoLoginSession;
+    redirectTo: string;
+}
+interface CallbackResponseError {
+    ok: false;
+    error: string;
+    errorDescription?: string;
+}
+export type CallbackResponse = CallbackResponseSuccess | CallbackResponseError;
+export declare class UnoLoginNextServer {
+    private readonly coreClient;
+    private readonly config;
+    constructor(config: UnoLoginNextServerConfig);
+    getSignInUrl(options?: SignInUrlOptions): {
+        url: string;
+        state: string;
+        stateCookie: string;
+    };
+    handleCallback(request: Request): Promise<CallbackResponse>;
+    getSession(request: Request): UnoLoginSession | null;
+    getSessionFromCookieHeader(cookieHeader: string | null): UnoLoginSession | null;
+    requireAuth(request: Request): UnoLoginSession;
+    buildSessionCookie(session: UnoLoginSession): string;
+    clearSessionCookie(): string;
+    clearStateCookie(): string;
+    private buildStateCookie;
+    private readStateFromRequest;
+}
+export {};

package/dist/packages/nextjs/src/server/client.js

@@ -0,0 +1,164 @@
+import { UnoLoginClient } from 'unologin-client/server';
+import { decodeSignedValue, encodeSignedValue, randomStateToken } from './crypto';
+import { parseCookieHeader, serializeCookie } from './cookies';
+const DEFAULT_SESSION_COOKIE = '__unologin_session';
+const DEFAULT_STATE_COOKIE = '__unologin_state';
+export class UnoLoginNextServer {
+    coreClient;
+    config;
+    constructor(config) {
+        this.config = {
+            ...config,
+            sessionCookieName: config.sessionCookieName ?? DEFAULT_SESSION_COOKIE,
+            stateCookieName: config.stateCookieName ?? DEFAULT_STATE_COOKIE,
+            secureCookies: config.secureCookies ?? true,
+        };
+        this.coreClient = new UnoLoginClient({
+            clientId: config.clientId,
+            clientSecret: config.clientSecret,
+            redirectUri: config.redirectUri,
+            unoLoginUrl: config.unoLoginUrl,
+        });
+    }
+    getSignInUrl(options = {}) {
+        const state = randomStateToken();
+        const url = this.coreClient.getAuthorizationUrl({
+            state,
+            prompt: options.prompt,
+            role: options.role,
+            tenantId: options.tenantId,
+            scope: options.scope,
+        });
+        const statePayload = {
+            state,
+            redirectTo: options.redirectTo ?? '/',
+        };
+        const stateCookie = this.buildStateCookie(statePayload);
+        return { url, state, stateCookie };
+    }
+    async handleCallback(request) {
+        const requestUrl = new URL(request.url);
+        const code = requestUrl.searchParams.get('code');
+        const state = requestUrl.searchParams.get('state');
+        const error = requestUrl.searchParams.get('error');
+        const errorDescription = requestUrl.searchParams.get('error_description');
+        if (error) {
+            return {
+                ok: false,
+                error,
+                errorDescription: errorDescription ?? undefined,
+            };
+        }
+        if (!code || !state) {
+            return { ok: false, error: 'invalid_callback' };
+        }
+        const authState = this.readStateFromRequest(request);
+        if (!authState || authState.state !== state) {
+            return { ok: false, error: 'invalid_state' };
+        }
+        try {
+            const tokenPair = await this.coreClient.exchangeCode(code);
+            const user = await this.coreClient.getUserInfo(tokenPair.accessToken);
+            const session = {
+                accessToken: tokenPair.accessToken,
+                refreshToken: tokenPair.refreshToken,
+                user,
+                createdAt: Date.now(),
+            };
+            return {
+                ok: true,
+                session,
+                redirectTo: authState.redirectTo,
+            };
+        }
+        catch {
+            return { ok: false, error: 'token_exchange_failed' };
+        }
+    }
+    getSession(request) {
+        return this.getSessionFromCookieHeader(request.headers.get('cookie'));
+    }
+    getSessionFromCookieHeader(cookieHeader) {
+        const cookies = parseCookieHeader(cookieHeader);
+        const raw = cookies[this.config.sessionCookieName];
+        if (!raw) {
+            return null;
+        }
+        const payload = decodeSignedValue(raw, this.config.cookieSecret);
+        if (!payload) {
+            return null;
+        }
+        try {
+            return JSON.parse(payload);
+        }
+        catch {
+            return null;
+        }
+    }
+    requireAuth(request) {
+        const session = this.getSession(request);
+        if (!session) {
+            throw new Error('Unauthorized');
+        }
+        return session;
+    }
+    buildSessionCookie(session) {
+        const encoded = encodeSignedValue(JSON.stringify(session), this.config.cookieSecret);
+        return serializeCookie(this.config.sessionCookieName, encoded, {
+            httpOnly: true,
+            secure: this.config.secureCookies,
+            sameSite: 'lax',
+            path: '/',
+            maxAge: 60 * 60 * 24 * 7,
+            domain: this.config.cookieDomain,
+        });
+    }
+    clearSessionCookie() {
+        return serializeCookie(this.config.sessionCookieName, '', {
+            httpOnly: true,
+            secure: this.config.secureCookies,
+            sameSite: 'lax',
+            path: '/',
+            maxAge: 0,
+            domain: this.config.cookieDomain,
+        });
+    }
+    clearStateCookie() {
+        return serializeCookie(this.config.stateCookieName, '', {
+            httpOnly: true,
+            secure: this.config.secureCookies,
+            sameSite: 'lax',
+            path: '/',
+            maxAge: 0,
+            domain: this.config.cookieDomain,
+        });
+    }
+    buildStateCookie(payload) {
+        const encoded = encodeSignedValue(JSON.stringify(payload), this.config.cookieSecret);
+        return serializeCookie(this.config.stateCookieName, encoded, {
+            httpOnly: true,
+            secure: this.config.secureCookies,
+            sameSite: 'lax',
+            path: '/',
+            maxAge: 60 * 10,
+            domain: this.config.cookieDomain,
+        });
+    }
+    readStateFromRequest(request) {
+        const cookies = parseCookieHeader(request.headers.get('cookie'));
+        const rawState = cookies[this.config.stateCookieName];
+        if (!rawState) {
+            return null;
+        }
+        const decoded = decodeSignedValue(rawState, this.config.cookieSecret);
+        if (!decoded) {
+            return null;
+        }
+        try {
+            return JSON.parse(decoded);
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/packages/nextjs/src/server/cookies.d.ts

@@ -0,0 +1,10 @@
+export interface CookieOptions {
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none';
+    path?: string;
+    maxAge?: number;
+    domain?: string;
+}
+export declare function parseCookieHeader(headerValue: string | null): Record<string, string>;
+export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;

package/dist/packages/nextjs/src/server/cookies.js

@@ -0,0 +1,37 @@
+export function parseCookieHeader(headerValue) {
+    if (!headerValue) {
+        return {};
+    }
+    return headerValue
+        .split(';')
+        .map((chunk) => chunk.trim())
+        .filter(Boolean)
+        .reduce((acc, chunk) => {
+        const idx = chunk.indexOf('=');
+        if (idx < 0) {
+            return acc;
+        }
+        const key = decodeURIComponent(chunk.slice(0, idx).trim());
+        const value = decodeURIComponent(chunk.slice(idx + 1));
+        acc[key] = value;
+        return acc;
+    }, {});
+}
+export function serializeCookie(name, value, options = {}) {
+    const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+    if (options.maxAge !== undefined) {
+        parts.push(`Max-Age=${Math.floor(options.maxAge)}`);
+    }
+    parts.push(`Path=${options.path ?? '/'}`);
+    if (options.domain) {
+        parts.push(`Domain=${options.domain}`);
+    }
+    if (options.httpOnly ?? true) {
+        parts.push('HttpOnly');
+    }
+    if (options.secure ?? true) {
+        parts.push('Secure');
+    }
+    parts.push(`SameSite=${options.sameSite ?? 'Lax'}`);
+    return parts.join('; ');
+}

package/dist/packages/nextjs/src/server/crypto.d.ts

@@ -0,0 +1,3 @@
+export declare function randomStateToken(): string;
+export declare function encodeSignedValue(value: string, secret: string): string;
+export declare function decodeSignedValue(value: string, secret: string): string | null;

package/dist/packages/nextjs/src/server/crypto.js

@@ -0,0 +1,38 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+function toBase64Url(value) {
+    return Buffer.from(value, 'utf8').toString('base64url');
+}
+function fromBase64Url(value) {
+    return Buffer.from(value, 'base64url').toString('utf8');
+}
+function sign(value, secret) {
+    return createHmac('sha256', secret).update(value).digest('base64url');
+}
+export function randomStateToken() {
+    return randomBytes(24).toString('base64url');
+}
+export function encodeSignedValue(value, secret) {
+    const encoded = toBase64Url(value);
+    return `${encoded}.${sign(encoded, secret)}`;
+}
+export function decodeSignedValue(value, secret) {
+    const [encoded, mac] = value.split('.');
+    if (!encoded || !mac) {
+        return null;
+    }
+    const expected = sign(encoded, secret);
+    const macBuffer = Buffer.from(mac);
+    const expectedBuffer = Buffer.from(expected);
+    if (macBuffer.length !== expectedBuffer.length) {
+        return null;
+    }
+    if (!timingSafeEqual(macBuffer, expectedBuffer)) {
+        return null;
+    }
+    try {
+        return fromBase64Url(encoded);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/packages/nextjs/src/server/env.d.ts

@@ -0,0 +1,11 @@
+import type { UnoLoginNextServerConfig } from './types';
+export interface UnoLoginEnvInput {
+    UNOLOGIN_URL?: string;
+    UNOLOGIN_CLIENT_ID?: string;
+    UNOLOGIN_CLIENT_SECRET?: string;
+    UNOLOGIN_REDIRECT_URI?: string;
+    UNOLOGIN_COOKIE_SECRET?: string;
+    UNOLOGIN_COOKIE_DOMAIN?: string;
+    NODE_ENV?: string;
+}
+export declare function configFromEnv(env?: UnoLoginEnvInput): UnoLoginNextServerConfig;