nuxt-umbu 0.0.1

package/dist/runtime/passport/plugin.js

@@ -0,0 +1,282 @@
+import {
+  defineNuxtPlugin,
+  useRequestEvent,
+  navigateTo,
+  useAuthStore,
+  useAuthConfig,
+  useRuntimeConfig,
+  createError
+} from "#imports";
+import { parseCookies, setCookie } from "h3";
+import { $fetch } from "ofetch";
+export default defineNuxtPlugin(async (nuxtApp) => {
+  const store = useAuthStore();
+  class Auth {
+    $headers;
+    _state = { user: null, loggedIn: false, strategy: "" };
+    _prefix;
+    options;
+    constructor(options) {
+      this.$headers = new Headers();
+      this._prefix = options.cookie.prefix;
+      this.options = options;
+    }
+    get state() {
+      return this._state;
+    }
+    get user() {
+      return this._state.user;
+    }
+    get strategy() {
+      return this._state.strategy;
+    }
+    get loggedIn() {
+      return this._state.loggedIn;
+    }
+    get headers() {
+      return this.$headers;
+    }
+    get prefix() {
+      return this._prefix;
+    }
+    set headers(headers) {
+      this.$headers = headers;
+    }
+    set state(val) {
+      this._state = val;
+    }
+    getRedirect(strategyName) {
+      return this.options.strategies?.[strategyName]?.redirect ?? null;
+    }
+    getUserProperty(strategyName) {
+      return this.options.strategies?.[strategyName]?.user?.property ?? null;
+    }
+    getEndpointsUser(strategyName) {
+      return this.options.strategies?.[strategyName]?.endpoints.user ?? null;
+    }
+    getHandler(strategyName, key) {
+      return this.options.strategies?.[strategyName]?.handler?.find((value) => value[key])?.[key] ?? null;
+    }
+    hasValidProperty(obj, key) {
+      if (!obj || !key) return false;
+      const value = obj[key];
+      return value !== null && value !== void 0;
+    }
+    async initialize() {
+      try {
+        let strategy = null;
+        let token = null;
+        if (import.meta.server) {
+          const event2 = useRequestEvent();
+          if (!event2) {
+            console.warn("No request event available. Skipping initialization.");
+            return;
+          }
+          const cookies = parseCookies(event2);
+          strategy = cookies[this._prefix + `strategy`];
+          token = strategy ? cookies[this._prefix + `_token.` + strategy] : null;
+        } else {
+          strategy = localStorage.getItem(this._prefix + `strategy`);
+          token = strategy ? localStorage.getItem(this._prefix + `_token.` + strategy) : null;
+        }
+        if (!strategy || !token) {
+          console.warn("No valid session found. Skipping profile fetch.");
+          return;
+        }
+        this._state.strategy = strategy ?? null;
+        this.$headers.set("Authorization", token);
+        const data = await this._setProfile();
+        if (data) {
+          const property = this.getUserProperty(this._state.strategy);
+          const user = this.hasValidProperty(data, property) ? data[property] : data ?? null;
+          this._state = {
+            user,
+            loggedIn: true,
+            strategy: strategy ?? null
+          };
+        }
+      } catch (error) {
+        console.error("Failed to initialize auth:", error);
+      }
+    }
+    async loginWith(strategyName, value) {
+      try {
+        const loginUrl = this.getHandler(strategyName, "login");
+        if (!loginUrl) throw new Error("Login endpoint not found");
+        const response = await $fetch(loginUrl, {
+          method: "POST",
+          body: { strategyName, value }
+        });
+        if (!response.token) throw new Error("Token is missing in the response");
+        localStorage.setItem(this._prefix + `_token.` + strategyName, response.token);
+        localStorage.setItem(this._prefix + `strategy`, strategyName);
+        localStorage.setItem(this._prefix + `_token_expiration.` + strategyName, response.expires);
+        this._state.strategy = strategyName ?? null;
+        this.$headers.set("Authorization", response.token);
+        const data = await this._setProfile();
+        if (!data) {
+          throw new Error("Failed to load user profile.");
+        }
+        const redirectUrl = this.getRedirect(strategyName)?.login;
+        if (redirectUrl) {
+          await navigateTo(redirectUrl);
+        }
+        return response ?? Promise.reject("No data returned");
+      } catch (error) {
+        console.error("Login failed:", error);
+        return Promise.reject(error);
+      }
+    }
+    async logout(strategyName) {
+      try {
+        const logoutUrl = this.getHandler(strategyName, "logout");
+        if (!logoutUrl) throw new Error("Logout endpoint not found");
+        const response = await $fetch(logoutUrl, {
+          method: "POST",
+          body: { strategyName }
+        });
+        this._state = {
+          user: null,
+          loggedIn: false,
+          strategy: ""
+        };
+        store.value = this._state;
+        Object.keys(localStorage).filter((key) => key.startsWith(this._prefix)).forEach((key) => localStorage.removeItem(key));
+        const redirectUrl = this.getRedirect(strategyName)?.logout ?? "/";
+        await navigateTo(redirectUrl);
+      } catch (error) {
+        console.error("Logout failed:", error);
+      }
+    }
+    async _2fa(strategyName, code) {
+      try {
+        if (!code) {
+          throw new Error("2FA code is required");
+        }
+        const twoFaUrl = this.getHandler(strategyName, "2fa");
+        if (!twoFaUrl) {
+          throw new Error("2FA endpoint not found");
+        }
+        const response = await $fetch(twoFaUrl, {
+          method: "POST",
+          body: { strategyName, code }
+        });
+        if (!response?.token || !response?.expires) {
+          throw new Error("Invalid 2FA response");
+        }
+        if (import.meta.client) {
+          localStorage.setItem(this._prefix + "_2fa." + strategyName, response.token);
+          localStorage.setItem(this._prefix + "_2fa_expiration." + strategyName, response.expires);
+        }
+        this.$headers.set("2fa", response.token);
+        return { success: true };
+      } catch (error) {
+        console.error("2FA failed:", error);
+        return Promise.reject(error);
+      }
+    }
+    async refreshToken(strategyName) {
+      return new Promise((resolve, reject) => {
+      });
+    }
+    async csrfToken(event2) {
+      try {
+        const baseURL = useRuntimeConfig().public.baseURL;
+        const csrfEndpoint = this.options?.csrf;
+        if (!csrfEndpoint) {
+          return false;
+        }
+        const data = await $fetch(csrfEndpoint, { baseURL });
+        if (!data?.csrf_token) {
+          throw new Error("Invalid CSRF response: Missing token.");
+        }
+        this.$headers.set("X-CSRF-TOKEN", data.csrf_token);
+        if (import.meta.server && event2) {
+          const cookies = parseCookies(event2);
+          const csrfCookie = cookies["X-CSRF-TOKEN"];
+          if (!csrfCookie) {
+            setCookie(
+              event2,
+              "X-CSRF-TOKEN",
+              data.csrf_token,
+              this.options.cookie.options || {
+                httpOnly: true,
+                secure: true,
+                sameSite: "strict",
+                path: "/"
+              }
+            );
+          }
+        }
+        return true;
+      } catch (error) {
+        console.error("Error fetching CSRF token:", error instanceof Error ? error.message : error);
+        return false;
+      }
+    }
+    async _setProfile() {
+      try {
+        const baseURL = useRuntimeConfig().public.baseURL;
+        const endpoint = this.getEndpointsUser(this._state.strategy);
+        if (!endpoint?.url || !endpoint?.method) return false;
+        const headers = this.$headers instanceof Headers ? Object.fromEntries(this.$headers.entries()) : this.$headers;
+        const data = await $fetch(endpoint.url, {
+          baseURL,
+          method: endpoint.method,
+          headers: {
+            ...headers,
+            "Content-Type": "application/json"
+          }
+        });
+        if (!data) return false;
+        const property = this.getUserProperty(this._state.strategy);
+        const user = this.hasValidProperty(data, property) ? data[property] : data ?? null;
+        store.value = {
+          user,
+          strategy: this._state.strategy ?? null,
+          loggedIn: true
+        };
+        this._state = store.value;
+        return data;
+      } catch (error) {
+        throw createError({
+          statusCode: error.statusCode,
+          statusMessage: "Access denied"
+        });
+      }
+    }
+  }
+  const $auth = new Auth(useAuthConfig());
+  const event = import.meta.server ? useRequestEvent() : void 0;
+  await $auth.csrfToken(event);
+  await $auth.initialize();
+  const exposed = Object.defineProperties(
+    {},
+    {
+      state: { get: () => $auth.state },
+      user: { get: () => $auth.user },
+      strategy: { get: () => $auth.strategy },
+      loggedIn: { get: () => $auth.loggedIn },
+      headers: {
+        get: () => $auth.headers,
+        set: (headers) => {
+          $auth.headers = headers;
+        }
+      },
+      prefix: { get: () => $auth.prefix }
+    }
+  );
+  exposed.getRedirect = (strategyName) => {
+    return $auth.getRedirect?.(strategyName) ?? null;
+  };
+  exposed.loginWith = async (strategyName, value) => {
+    return await $auth.loginWith(strategyName, value);
+  };
+  exposed.logout = async (strategyName) => {
+    return await $auth.logout(strategyName);
+  };
+  exposed._2fa = async (strategyName, code) => {
+    return await $auth._2fa(strategyName, code);
+  };
+  nuxtApp.provide("auth", exposed);
+});

package/dist/runtime/passport/server/api/2fa.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    token: string;
+    expires: number;
+}>>;
+export default _default;

package/dist/runtime/passport/server/api/2fa.js

@@ -0,0 +1,78 @@
+import { useRuntimeConfig } from "#imports";
+import { defineEventHandler, readBody, getCookie, setCookie, createError, setHeader } from "h3";
+import { $fetch } from "ofetch";
+import protectedMiddleware from "../middleware/protected.js";
+export default defineEventHandler(async (event) => {
+  try {
+    await protectedMiddleware(event);
+    const body = await readBody(event);
+    if (!body?.strategyName || !body?.code) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Missing required parameters: strategyName or code"
+      });
+    }
+    const runtimeConfig = useRuntimeConfig();
+    const baseURL = runtimeConfig.public.baseURL;
+    const config = runtimeConfig.public["nuxt-umbu"];
+    if (!config) {
+      throw createError({ statusCode: 500, statusMessage: "Authentication module not configured" });
+    }
+    const { cookie, strategies } = config;
+    const prefix = cookie?.prefix || "auth.";
+    const strategy = strategies?.[body.strategyName];
+    if (!strategy) {
+      throw createError({ statusCode: 400, statusMessage: "Invalid authentication strategy" });
+    }
+    const { endpoints } = strategy;
+    if (!endpoints?.["2fa"]) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "2FA endpoint not configured for strategy " + body.strategyName
+      });
+    }
+    const token = getCookie(event, prefix + "_token." + body.strategyName) || "";
+    const response = await $fetch(endpoints["2fa"].url, {
+      baseURL,
+      method: endpoints["2fa"].method || "POST",
+      body: { code: body.code },
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: token
+      },
+      onRequest({ options }) {
+        options.headers = options.headers || {};
+        setHeader(event, "Authorization", token);
+      }
+    }).catch((error) => {
+      console.error("[API Error]", error);
+      throw createError({ statusCode: 401, statusMessage: "Authentication processing failed" });
+    });
+    if (!response?.access_token || !response?.expires_in) {
+      throw createError({
+        statusCode: 500,
+        statusMessage: "Invalid 2FA response structure"
+      });
+    }
+    const expires = Date.now() + response.expires_in * 1e3;
+    setCookie(
+      event,
+      prefix + "_2fa." + body.strategyName,
+      response.access_token,
+      cookie?.options || {}
+    );
+    setCookie(
+      event,
+      prefix + "_2fa_expiration." + body.strategyName,
+      expires.toString(),
+      cookie?.options || {}
+    );
+    return { token: response.access_token, expires };
+  } catch (error) {
+    console.error("[Auth Error]", error);
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch 2FA token"
+    });
+  }
+});

package/dist/runtime/passport/server/api/login.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    token: string;
+    refresh_token: any;
+    expires: number;
+}>>;
+export default _default;

package/dist/runtime/passport/server/api/login.js

@@ -0,0 +1,63 @@
+import { useRuntimeConfig } from "#imports";
+import { defineEventHandler, readBody, setCookie, createError } from "h3";
+import { defu } from "defu";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  try {
+    const body = await readBody(event);
+    if (!body?.strategyName || !body?.value) {
+      throw createError({ statusCode: 400, statusMessage: "Invalid request body" });
+    }
+    const runtimeConfig = useRuntimeConfig();
+    const baseURL = runtimeConfig.public.baseURL;
+    const config = runtimeConfig.public["nuxt-umbu"];
+    const secret = runtimeConfig.secret;
+    if (!config) {
+      throw createError({ statusCode: 500, statusMessage: "Authentication module not configured" });
+    }
+    const { cookie, strategies } = config;
+    const prefix = cookie?.prefix || "auth.";
+    const strategy = strategies?.[body.strategyName];
+    if (!strategy) {
+      throw createError({ statusCode: 400, statusMessage: "Invalid authentication strategy" });
+    }
+    const { endpoints } = strategy;
+    if (!endpoints?.login?.url) {
+      throw createError({ statusCode: 500, statusMessage: "Login endpoint not configured" });
+    }
+    const credentials = defu(body.value, secret?.[body.strategyName]);
+    const response = await $fetch(endpoints.login.url, {
+      baseURL,
+      method: endpoints.login.method || "POST",
+      body: credentials,
+      timeout: 1e4,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    }).catch((error) => {
+      console.error("[API Error]", error);
+      throw createError({ statusCode: 401, statusMessage: "Authentication processing failed" });
+    });
+    if (!response?.access_token || !response?.refresh_token || !response?.expires_in) {
+      throw createError({ statusCode: 502, statusMessage: "Invalid token response" });
+    }
+    const token = "Bearer " + response.access_token;
+    const expires = Date.now() + response.expires_in * 1e3;
+    setCookie(event, prefix + "_token." + body.strategyName, token, cookie?.options || {});
+    setCookie(event, prefix + "strategy", body.strategyName, cookie?.options || {});
+    setCookie(
+      event,
+      prefix + "_token_expiration." + body.strategyName,
+      expires.toString(),
+      cookie?.options || {}
+    );
+    return { token, refresh_token: response.refresh_token, expires };
+  } catch (error) {
+    console.error("[Auth Error]", error);
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Authentication failed"
+    });
+  }
+});

package/dist/runtime/passport/server/api/logout.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    success: boolean;
+    redirect: import("../../../types/index.js").RedirectOptions;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    redirect?: undefined;
+}>>;
+export default _default;

package/dist/runtime/passport/server/api/logout.js

@@ -0,0 +1,37 @@
+import { useRuntimeConfig } from "#imports";
+import { deleteCookie, defineEventHandler, readBody } from "h3";
+import protectedMiddleware from "../middleware/protected.js";
+export default defineEventHandler(async (event) => {
+  try {
+    await protectedMiddleware(event);
+    const body = await readBody(event);
+    const strategyName = body?.strategyName;
+    if (!strategyName) {
+      throw new Error("Strategy name is required.");
+    }
+    const runtimeConfig = useRuntimeConfig();
+    const config = runtimeConfig.public["nuxt-umbu"];
+    if (!config) {
+      throw new Error("Auth configuration is missing.");
+    }
+    const { cookie, strategies, twoFactorAuth } = config;
+    const prefix = (cookie?.prefix && !import.meta.dev ? cookie.prefix : "auth.") + "";
+    const strategyConfig = strategies[strategyName];
+    if (!strategyConfig) {
+      throw new Error("Strategy " + strategyName + " is not defined in the configuration.");
+    }
+    const { redirect } = strategyConfig;
+    const cookieOptions = cookie?.options ?? {};
+    deleteCookie(event, prefix + "_token." + strategyName, cookieOptions);
+    deleteCookie(event, prefix + "strategy", cookieOptions);
+    deleteCookie(event, prefix + "_token_expiration." + strategyName, cookieOptions);
+    if (twoFactorAuth) {
+      deleteCookie(event, prefix + "_2fa." + strategyName, cookieOptions);
+      deleteCookie(event, prefix + "_2fa_expiration." + strategyName, cookieOptions);
+    }
+    return { success: true, redirect };
+  } catch (error) {
+    console.error("Error in logout handler:", error);
+    return { success: false, error: error.message };
+  }
+});

package/dist/runtime/passport/server/api/refresh.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    token: string;
+    refresh_token: any;
+    expires: number;
+}>>;
+export default _default;

package/dist/runtime/passport/server/api/refresh.js

@@ -0,0 +1,72 @@
+import { useRuntimeConfig } from "#imports";
+import { defineEventHandler, readBody, setCookie, createError, getCookie } from "h3";
+import { $fetch } from "ofetch";
+import protectedMiddleware from "../middleware/protected.js";
+export default defineEventHandler(async (event) => {
+  try {
+    await protectedMiddleware(event);
+    const body = await readBody(event);
+    if (!body?.strategyName) {
+      throw createError({ statusCode: 400, statusMessage: "Invalid request body" });
+    }
+    const runtimeConfig = useRuntimeConfig();
+    const baseURL = runtimeConfig.public.baseURL;
+    const config = runtimeConfig.public["nuxt-umbu"];
+    if (!config) {
+      throw createError({ statusCode: 500, statusMessage: "Authentication module not configured" });
+    }
+    const { cookie, strategies } = config;
+    const prefix = cookie?.prefix || "auth.";
+    const strategy = strategies?.[body.strategyName];
+    if (!strategy) {
+      throw createError({ statusCode: 400, statusMessage: "Invalid authentication strategy" });
+    }
+    const { endpoints } = strategy;
+    if (!endpoints?.refresh?.url) {
+      throw createError({ statusCode: 500, statusMessage: "Refresh endpoint not configured" });
+    }
+    const refreshToken = getCookie(event, prefix + `_refresh_token.` + body.strategyName);
+    if (!refreshToken) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: "No refresh token found. Please log in again."
+      });
+    }
+    const response = await $fetch(endpoints.refresh.url, {
+      baseURL,
+      method: endpoints.refresh.method || "POST",
+      body: { refresh_token: refreshToken },
+      timeout: 1e4,
+      headers: { "Content-Type": "application/json" }
+    }).catch((error) => {
+      console.error("[API Error]", error);
+      throw createError({ statusCode: 502, statusMessage: "Authentication service error" });
+    });
+    if (!response?.access_token || !response?.refresh_token || !response?.expires_in) {
+      throw createError({ statusCode: 502, statusMessage: "Invalid token response" });
+    }
+    const token = "Bearer " + response.access_token;
+    const expires = Date.now() + response.expires_in * 1e3;
+    setCookie(event, prefix + "_token." + body.strategyName, token, cookie?.options || {});
+    setCookie(
+      event,
+      prefix + `_refresh_token.` + body.strategyName,
+      response.refresh_token,
+      cookie?.options || {}
+    );
+    setCookie(event, prefix + "strategy", body.strategyName, cookie?.options || {});
+    setCookie(
+      event,
+      prefix + "_token_expiration." + body.strategyName,
+      expires.toString(),
+      cookie?.options || {}
+    );
+    return { token, refresh_token: response.refresh_token, expires };
+  } catch (error) {
+    console.error("[Auth Error]", error);
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Authentication failed"
+    });
+  }
+});

package/dist/runtime/passport/server/api/session.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    token: string | undefined;
+    expires: string | undefined;
+    strategyName: string | undefined;
+    loggedIn: boolean;
+}>>;
+export default _default;

package/dist/runtime/passport/server/api/session.js

@@ -0,0 +1,16 @@
+import { defineEventHandler, createError } from "h3";
+import { getAuthSession } from "../utils/index.js";
+import protectedMiddleware from "../middleware/protected.js";
+export default defineEventHandler(async (event) => {
+  try {
+    await protectedMiddleware(event);
+    const { token, expires, strategyName } = getAuthSession(event);
+    return { token, expires, strategyName, loggedIn: true };
+  } catch (error) {
+    console.error("[Auth Error] " + error);
+    throw createError({
+      statusCode: error.statusCode ? error.statusCode : 500,
+      statusMessage: error.statusMessage ? error.statusMessage : "Authentication failed"
+    });
+  }
+});

package/dist/runtime/passport/server/middleware/protected.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/passport/server/middleware/protected.js

@@ -0,0 +1,17 @@
+import { defineEventHandler, createError } from "h3";
+import { getAuthSession } from "../utils/index.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const { token, expires } = getAuthSession(event);
+    if (!token) {
+      throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+    }
+    const expirationTime = expires ? Number(expires) : NaN;
+    if (isNaN(expirationTime) || expirationTime < Date.now()) {
+      throw createError({ statusCode: 401, statusMessage: "Session expired" });
+    }
+  } catch (error) {
+    console.error("[Auth Error] ", error);
+    throw error.statusCode ? error : createError({ statusCode: 500, statusMessage: "Authentication failed" });
+  }
+});

package/dist/runtime/passport/server/utils/index.d.ts

@@ -0,0 +1,14 @@
+import { H3Event } from 'h3';
+interface AuthSession {
+    token?: string;
+    expires?: string;
+    strategyName?: string;
+}
+/**
+ * Retrieves the authentication session from HTTP-only cookies.
+ * @param event The H3 event from the request.
+ * @returns An object containing token, expires, and strategyName.
+ * @throws An error if the authentication configuration is missing.
+ */
+export declare function getAuthSession(event: H3Event): AuthSession;
+export {};

package/dist/runtime/passport/server/utils/index.js

@@ -0,0 +1,14 @@
+import { useRuntimeConfig } from "#imports";
+import { getCookie, createError } from "h3";
+export function getAuthSession(event) {
+  const runtimeConfig = useRuntimeConfig();
+  const config = runtimeConfig.public["nuxt-umbu"];
+  if (!config?.cookie) {
+    throw createError({ statusCode: 500, statusMessage: "Authentication module not configured" });
+  }
+  const prefix = config.cookie.prefix || "auth.";
+  const strategyName = getCookie(event, prefix + "strategy") || void 0;
+  const token = strategyName ? getCookie(event, prefix + "_token." + strategyName) || void 0 : void 0;
+  const expires = strategyName ? getCookie(event, prefix + "_token_expiration." + strategyName) || void 0 : void 0;
+  return { token, expires, strategyName };
+}

package/dist/runtime/passport/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './middleware.js';

package/dist/runtime/passport/utils/index.js

@@ -0,0 +1 @@
+export * from "./middleware.js";

package/dist/runtime/passport/utils/middleware.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Handles user logout by clearing session data and redirecting.
+ * @param strategy - The authentication strategy to log out from.
+ * @param redirectPath - The path to redirect after logout.
+ * @param middleware - The middleware type, defaults to "auth".
+ * @throws An error if called on the server side.
+ */
+export declare const handleLogout: (strategy: string | null, redirectPath: string, middleware?: string) => Promise<string | false | void | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").NavigationFailure>;
+/**
+ * Validates an authentication session based on token and expiration time.
+ * @param strategy - The authentication strategy in use.
+ * @param token - The authentication token.
+ * @param expires - Expiration timestamp of the token.
+ * @returns `true` if the session is valid, otherwise `false`.
+ */
+export declare const validateSession: (strategy: string | null, token: string | null, expires: string | null) => boolean;
+/**
+ * Retrieves the appropriate redirect path based on the authentication strategy.
+ * @param strategy - The authentication strategy in use.
+ * @returns The redirect path for login, callback, or home, defaults to `/` if none is found.
+ */
+export declare const getRedirectPath: (strategy: string | null) => string;