nuxt-feathers-zod 6.4.73 → 6.4.98

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 6.4.98
+
+- fix(dev/playground): create a self-link `playground/node_modules/nuxt-feathers-zod` so local `nuxi dev playground` resolves `nuxt-feathers-zod/*` bare imports correctly under the nested playground package scope.
+- chore(scripts): run `playground:ensure-link` during `prepare`, `playground:dev`, and `playground:build`.
+
+## 6.4.95
+
+- add phase 4 auth runtime refactor helpers: `useProtectedTool()` and `useMongoManagementClient()`
+- expose safe public runtime metadata for Mongo management basePath and routes
+- align docs FR/EN for protected runtime tools and embedded Mongo management
+
+
+## 6.4.93
+
+- auth runtime phase 2: add `useAuthenticatedRequest()` and `useProtectedService()`
+- auth diagnostics: add `useAuthDiagnostics()` and `getStateSnapshot()`
+- generated client plugin now synchronizes remote auth results with the unified auth runtime
+- documentation FR/EN aligned with unified auth runtime and Keycloak bridge behavior
+
 ## v6.4.57
 
 - positionnement produit clarifié face à `@nuxtjs/supabase` (README + docs)
@@ -246,3 +265,16 @@
 - devtools plume icon/theme-parent behavior preserved
 
 - 6.4.45: remote Keycloak Option B contract (`strategy: 'sso'`, `user: loginuser`, `authenticated: true`) is now first-class in the runtime and docs; generated route middleware no longer re-runs `auth.init()` or reuses callback hashes in redirect URIs.
+
+## 6.4.94
+
+- auth runtime refactor phase 3: add `useAuthBoundFetch()` and auth-aware REST fetch implementation
+- generated REST clients now use the auth-bound fetch implementation by default
+- `useProtectedService()` retries once after `reAuthenticate()` on 401
+- docs FR/EN updated for phase 3 runtime auth usage
+
+
+## 6.4.96
+- auth runtime phase 5: official Keycloak bridge helper and richer diagnostics
+- protected helpers now validate Keycloak bearer before protected calls
+- docs FR/EN aligned on auth runtime phases 3/4/5

package/README.md

@@ -1,12 +1,12 @@
 # nuxt-feathers-zod
 
-> OSS reference snapshot: **v6.4.73** — optional Mongo management options aligned and release metadata synchronized.
+> OSS reference snapshot: **v6.4.98** — optional Mongo management options aligned and release metadata synchronized.
 
 [Documentation](https://vevedh.github.io/nuxt-feathers-zod/)
 
 `nuxt-feathers-zod` is the official **Nuxt 4** module that embeds or connects to **FeathersJS v5 (Dove)** with a **CLI-first** workflow and optional **Zod-first** service generation.
 
-Current OSS release target: **6.4.73**.
+Current OSS release target: **6.4.98**.
 
 It supports two main usage patterns:
 
@@ -157,7 +157,7 @@ bunx nuxt-feathers-zod middlewares list --target nitro
 bunx nuxt-feathers-zod middlewares add request-id --target nitro
 ```
 
-## CLI command surface in 6.4.73
+## CLI command surface in 6.4.98
 
 | Area | Commands |
 |---|---|
@@ -498,7 +498,52 @@ Le dashboard de démonstration associé au module peut désormais être packagé
 The Docker Edition can expose a reusable `License Center` page and feature-gating components to manage future licensed options for the `nuxt-feathers-zod` product surface.
 
 
-## 6.4.73 — License Center layout clarity
+## 6.4.87 — License Center layout clarity
 - La page /license-center côté dashboard de démonstration a été refondue pour une lecture plus claire et sans écrasement responsive.
 - Nouveau découpage : status + quick actions + runtime summary en haut, puis onglets Overview / Features / Plans.
 - Le breakpoint de colonnes latérales a été repoussé à 2xl pour éviter les défauts de mise en page sur desktop intermédiaire.
+
+
+## PATCH 6.4.93 auth runtime refactor (phase 2)
+
+- Added official protected runtime helpers: `useAuthenticatedRequest()` and `useProtectedService()`.
+- Added `useAuthDiagnostics()` and `getStateSnapshot()` for easier auth diagnostics.
+- Generated remote client plugin now synchronizes remote authenticate / reAuthenticate results with the unified auth runtime instead of only syncing a Pinia store.
+- Documentation FR/EN updated around the unified auth runtime, protected requests, protected services and Keycloak bridge behavior.
+- Recommended rule: protected NFZ tools must stop rebuilding Bearer headers manually and should consume the runtime helpers.
+
+## PATCH 6.4.92 auth runtime refactor (phase 1)
+
+- Unified client auth runtime added via `useAuthRuntime()`.
+- Single source of truth for token/user/authenticated/ready/status.
+- Keycloak SSO now syncs token and Keycloak user through a dedicated bridge flow before protected Feathers calls.
+- Generated Keycloak bridge service now accepts token aliases and keycloak user hints, and returns `accessToken`/`authentication` in its result.
+- Goal: eliminate auth drift between `$api`, raw Feathers client, Pinia auth store, storage, and runtime tools.
+
+
+
+## Unified auth runtime helpers
+
+`6.4.94` adds a stronger phase-3 runtime auth layer for protected REST/service flows:
+
+- `useAuthRuntime()` remains the single auth source of truth
+- `useAuthBoundFetch()` provides an auth-aware fetch helper with automatic bearer injection and one-shot `reAuthenticate()` retry on 401
+- `useAuthenticatedRequest()` now delegates to this helper
+- `useProtectedService()` retries once after `reAuthenticate()` on 401
+- generated REST Feathers clients now use the auth-bound fetch implementation by default
+
+This is especially useful for embedded REST mode, remote JWT mode, and Keycloak SSO bridging where a single runtime token must be reused consistently across Feathers services and protected HTTP routes.
+
+
+## 6.4.95
+
+- auth runtime refactor phase 4
+- official protected tool helpers: `useProtectedTool()` and `useMongoManagementClient()`
+- public runtime metadata for embedded Mongo management routes
+- better alignment between protected Feathers services and protected runtime tool HTTP routes
+
+## 6.4.96
+
+- auth runtime refactor phase 5: official Keycloak bridge helper `useKeycloakBridge()`
+- richer runtime diagnostics (`lastBridgeAt`, `lastEnsureReason`, `bridgePath`, `clientSync`)
+- `useAuthBoundFetch()` and `useProtectedService()` now explicitly validate the Keycloak bearer before protected calls

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^4.0.0"
   },
-  "version": "6.4.73",
+  "version": "6.4.98",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -491,7 +491,11 @@ function setAliases(options, nuxt) {
     "nuxt-feathers-zod/zod$": resolver.resolve("runtime/zod/index"),
     "nuxt-feathers-zod/options$": resolver.resolve("runtime/options"),
     "nuxt-feathers-zod/auth-utils$": resolver.resolve("runtime/utils/auth"),
-    "nuxt-feathers-zod/config-utils$": resolver.resolve("runtime/utils/config")
+    "nuxt-feathers-zod/config-utils$": resolver.resolve("runtime/utils/config"),
+    "nuxt-feathers-zod/auth-runtime$": resolver.resolve("runtime/composables/useAuthRuntime"),
+    "nuxt-feathers-zod/auth-bound-fetch$": resolver.resolve("runtime/composables/useAuthBoundFetch"),
+    "nuxt-feathers-zod/protected-tool$": resolver.resolve("runtime/composables/useProtectedTool"),
+    "nuxt-feathers-zod/mongo-management-client$": resolver.resolve("runtime/composables/useMongoManagementClient")
   };
   nuxt.options.alias = defu(nuxt.options.alias, aliases);
   if (options.client)

package/dist/runtime/client.d.ts

@@ -0,0 +1,9 @@
+import type { Application as FeathersApplication, TransportConnection } from '@feathersjs/feathers';
+export interface ServiceTypes {
+}
+export interface Configuration {
+    connection: TransportConnection<ServiceTypes>;
+}
+export type ClientApplication = FeathersApplication<ServiceTypes, Configuration>;
+export type FeathersClientPlugin = Parameters<ClientApplication['configure']>['0'];
+export declare function defineFeathersClientPlugin(def: FeathersClientPlugin): FeathersClientPlugin;

package/dist/runtime/client.js

@@ -0,0 +1,3 @@
+export function defineFeathersClientPlugin(def) {
+  return def;
+}

package/dist/runtime/composables/useAuth.d.ts

@@ -1,19 +1,20 @@
-type AuthProvider = 'keycloak' | 'local' | 'remote' | 'none';
 export declare function useAuth(): {
-    provider: import("vue").ComputedRef<AuthProvider>;
+    provider: import("vue").ComputedRef<"none" | "local" | "remote" | "keycloak">;
     ready: import("vue").Ref<boolean, boolean>;
+    status: import("vue").Ref<"error" | "idle" | "bootstrapping" | "authenticated" | "anonymous", "error" | "idle" | "bootstrapping" | "authenticated" | "anonymous">;
     isAuthenticated: import("vue").ComputedRef<boolean>;
     isSsoAuthenticated: import("vue").ComputedRef<boolean>;
     isFeathersAuthenticated: import("vue").ComputedRef<boolean>;
-    user: import("vue").ComputedRef<any>;
+    user: import("vue").Ref<any, any>;
     ssoUser: import("vue").ComputedRef<any>;
     feathersUser: import("vue").ComputedRef<any>;
-    permissions: import("vue").ComputedRef<any>;
-    token: import("vue").ComputedRef<string | null>;
+    permissions: import("vue").Ref<any[], any[]>;
+    token: import("vue").Ref<string | null, string | null>;
     ssoToken: import("vue").ComputedRef<string | null>;
     feathersToken: import("vue").ComputedRef<string | null>;
     init: () => Promise<void>;
     login: (options?: any) => Promise<any>;
     logout: (options?: any) => Promise<any>;
+    ensureReady: (reason?: string) => Promise<void>;
+    getAuthorizationHeader: () => Promise<string | null>;
 };
-export {};

package/dist/runtime/composables/useAuth.js

@@ -1,155 +1,47 @@
-import { useNuxtApp, useRuntimeConfig } from "#imports";
-import { computed, ref } from "vue";
-import { useAuthStore } from "../stores/auth.js";
-import { buildRemoteAuthPayload } from "../utils/auth.js";
-import { getForcedAuthProvider, getPublicClientMode, getPublicRemoteAuthConfig, hasPublicKeycloakConfig, isPublicRemoteAuthEnabled } from "../utils/config.js";
+import { useNuxtApp } from "#imports";
+import { computed } from "vue";
+import { useAuthRuntime } from "./useAuthRuntime.js";
 export function useAuth() {
+  const runtime = useAuthRuntime();
   const nuxtApp = useNuxtApp();
-  const rc = useRuntimeConfig();
-  const pub = rc.public;
-  const provider = computed(() => {
-    const forced = getForcedAuthProvider(pub);
-    if (forced === "keycloak")
-      return "keycloak";
-    if (forced === "remote")
-      return "remote";
-    if (forced === "local")
-      return "local";
-    const cm = getPublicClientMode(pub);
-    const remoteAuth = getPublicRemoteAuthConfig(pub);
-    if (hasPublicKeycloakConfig(pub) && cm === "remote" && remoteAuth?.enabled && remoteAuth?.payloadMode === "keycloak")
-      return "keycloak";
-    if (isPublicRemoteAuthEnabled(pub))
-      return "remote";
-    if (hasPublicKeycloakConfig(pub))
-      return "keycloak";
-    if (pub?._feathers?.auth)
-      return "local";
-    return "none";
-  });
-  const ready = ref(false);
-  const keycloak = computed(() => nuxtApp.$keycloak);
-  const authStore = computed(() => {
-    try {
-      return useAuthStore();
-    } catch {
-      return null;
-    }
-  });
-  const ssoUser = computed(() => {
-    const kc = keycloak.value;
-    return kc?.user ?? (kc?.tokenParsed ? { ...kc.tokenParsed, userid: kc.userid ?? kc.tokenParsed?.preferred_username } : null);
-  });
-  const feathersUser = computed(() => authStore.value?.user ?? null);
-  const ssoToken = computed(() => keycloak.value?.token?.() ?? null);
-  const feathersToken = computed(() => authStore.value?.accessToken ?? null);
-  const isSsoAuthenticated = computed(() => {
-    if (provider.value !== "keycloak")
-      return false;
-    return Boolean(keycloak.value?.authenticated);
-  });
-  const isFeathersAuthenticated = computed(() => {
-    if (provider.value === "keycloak")
-      return Boolean(authStore.value?.authenticated || keycloak.value?.authenticated);
-    if (provider.value === "local" || provider.value === "remote")
-      return Boolean(authStore.value?.authenticated);
-    return false;
-  });
-  const isAuthenticated = computed(() => {
-    if (provider.value === "keycloak")
-      return Boolean(isSsoAuthenticated.value || isFeathersAuthenticated.value);
-    if (provider.value === "local" || provider.value === "remote")
-      return Boolean(isFeathersAuthenticated.value);
-    return false;
-  });
-  const user = computed(() => {
-    if (provider.value === "keycloak")
-      return feathersUser.value ?? ssoUser.value ?? null;
-    if (provider.value === "local" || provider.value === "remote")
-      return feathersUser.value ?? null;
-    return null;
-  });
-  const permissions = computed(() => {
-    if (provider.value === "keycloak")
-      return keycloak.value?.permissions ?? [];
-    return [];
-  });
-  const token = computed(() => {
-    if (provider.value === "keycloak")
-      return feathersToken.value ?? ssoToken.value ?? null;
-    if (provider.value === "local" || provider.value === "remote")
-      return feathersToken.value ?? null;
-    return null;
-  });
+  const isSsoAuthenticated = computed(() => runtime.provider.value === "keycloak" && runtime.authenticated.value);
+  const isFeathersAuthenticated = computed(() => runtime.authenticated.value);
+  const isAuthenticated = computed(() => runtime.authenticated.value);
+  const ssoUser = computed(() => runtime.provider.value === "keycloak" ? runtime.user.value : null);
+  const feathersUser = computed(() => runtime.user.value);
+  const ssoToken = computed(() => runtime.provider.value === "keycloak" ? runtime.accessToken.value : null);
+  const feathersToken = computed(() => runtime.accessToken.value);
   async function init() {
-    if (import.meta.server)
-      return;
-    if (ready.value) {
-      if (provider.value !== "keycloak")
-        return;
-      if (!isAuthenticated.value)
-        return;
-      if (user.value)
-        return;
-    }
-    if (provider.value === "keycloak") {
-      const kc = keycloak.value;
-      if (kc?.authenticated && typeof kc.ensureFeathersAuth === "function")
-        await kc.ensureFeathersAuth("useAuth.init").catch(() => false);
-      if (kc?.authenticated && typeof kc.whoami === "function")
-        await kc.whoami().catch(() => null);
-    }
-    if (provider.value === "local" || provider.value === "remote") {
-      const s = authStore.value;
-      if (s?.restore) {
-        await s.restore().catch(() => {
-        });
-      } else {
-        const api = nuxtApp.$api;
-        await api?.reAuthenticate?.().catch(() => {
-        });
-      }
-    }
-    ready.value = true;
+    await runtime.ensureReady();
   }
   async function login(options) {
-    if (provider.value === "keycloak")
-      return keycloak.value?.login?.(options);
-    if (provider.value === "local")
-      return authStore.value?.authenticate?.(options);
-    if (provider.value === "remote") {
-      const pub2 = useRuntimeConfig().public;
-      const ra = getPublicRemoteAuthConfig(pub2);
-      const token2 = options?.token || options?.accessToken || options?.access_token;
-      if (!token2)
-        throw new Error("Remote login requires a token (options.token)");
-      const payload = buildRemoteAuthPayload(token2, ra);
-      return authStore.value?.authenticate?.(payload);
-    }
+    if (runtime.provider.value === "keycloak")
+      return nuxtApp.$keycloak?.login?.(options);
+    return runtime.authenticate(options);
   }
   async function logout(options) {
-    if (provider.value === "keycloak")
-      return keycloak.value?.logout?.(options);
-    if (provider.value === "local")
-      return authStore.value?.logout?.();
-    if (provider.value === "remote")
-      return authStore.value?.logout?.();
+    if (runtime.provider.value === "keycloak")
+      return nuxtApp.$keycloak?.logout?.(options);
+    return runtime.logout();
   }
   return {
-    provider,
-    ready,
+    provider: runtime.provider,
+    ready: runtime.ready,
+    status: runtime.status,
     isAuthenticated,
     isSsoAuthenticated,
     isFeathersAuthenticated,
-    user,
+    user: runtime.user,
     ssoUser,
     feathersUser,
-    permissions,
-    token,
+    permissions: runtime.permissions,
+    token: runtime.accessToken,
     ssoToken,
     feathersToken,
     init,
     login,
-    logout
+    logout,
+    ensureReady: runtime.ensureReady,
+    getAuthorizationHeader: runtime.getAuthorizationHeader
   };
 }

package/dist/runtime/composables/useAuthBoundFetch.d.ts

@@ -0,0 +1,6 @@
+export interface AuthBoundOptions extends RequestInit {
+    auth?: 'required' | 'optional' | 'none';
+    retryOn401?: boolean;
+}
+export declare function useAuthBoundFetchImplementation(defaults?: Partial<AuthBoundOptions>): (input: RequestInfo | URL, init?: AuthBoundOptions) => Promise<any>;
+export declare function useAuthBoundFetch(defaults?: Partial<AuthBoundOptions>): <T = any>(input: RequestInfo | URL, init?: AuthBoundOptions) => Promise<T>;

package/dist/runtime/composables/useAuthBoundFetch.js

@@ -0,0 +1,86 @@
+import { useRequestFetch } from "#imports";
+import { useAuthRuntime } from "./useAuthRuntime.js";
+function mergeHeaders(input, authorization) {
+  const headers = new Headers(input || {});
+  if (authorization && !headers.has("authorization") && !headers.has("Authorization")) {
+    headers.set("Authorization", authorization);
+  }
+  return headers;
+}
+function toRequestInit(input, init, headers) {
+  const request = input instanceof Request ? input : null;
+  const base = request ? {
+    method: request.method,
+    body: request.body,
+    credentials: request.credentials,
+    cache: request.cache,
+    integrity: request.integrity,
+    keepalive: request.keepalive,
+    mode: request.mode,
+    redirect: request.redirect,
+    referrer: request.referrer,
+    referrerPolicy: request.referrerPolicy,
+    signal: request.signal
+  } : {};
+  const result = {
+    ...base,
+    ...init,
+    headers
+  };
+  delete result.auth;
+  delete result.retryOn401;
+  return result;
+}
+function resolveNativeFetch() {
+  if (import.meta.server)
+    return useRequestFetch();
+  if (typeof window !== "undefined" && typeof window.fetch === "function")
+    return window.fetch.bind(window);
+  if (typeof globalThis.fetch === "function")
+    return globalThis.fetch.bind(globalThis);
+  throw new Error("[nuxt-feathers-zod] No native fetch implementation available");
+}
+export function useAuthBoundFetchImplementation(defaults = {}) {
+  const auth = useAuthRuntime();
+  const nativeFetch = resolveNativeFetch();
+  return async function authBoundFetch(input, init = {}) {
+    const authMode = init.auth ?? defaults.auth ?? "required";
+    const retryOn401 = init.retryOn401 ?? defaults.retryOn401 ?? true;
+    if (authMode !== "none") {
+      await auth.ensureReady("auth-bound-fetch");
+      if (auth.provider.value === "keycloak")
+        await auth.ensureValidatedBearer("auth-bound-fetch");
+    }
+    async function execute() {
+      const authorization = authMode === "none" ? null : await auth.getAuthorizationHeader();
+      const headers = mergeHeaders(init.headers, authorization);
+      return await nativeFetch(input, toRequestInit(input, init, headers));
+    }
+    let response = await execute();
+    if (authMode !== "none" && retryOn401 && response.status === 401) {
+      await auth.reAuthenticate().catch(() => null);
+      response = await execute();
+    }
+    return response;
+  };
+}
+export function useAuthBoundFetch(defaults = {}) {
+  const request = useAuthBoundFetchImplementation(defaults);
+  return async function authBoundRequest(input, init = {}) {
+    const response = await request(input, init);
+    if (response.status === 204)
+      return null;
+    const contentType = response.headers.get("content-type") || "";
+    const payload = contentType.includes("application/json") ? await response.json() : await response.text();
+    if (!response.ok) {
+      throw {
+        name: "AuthBoundFetchError",
+        message: payload?.message || response.statusText || "Request failed",
+        status: response.status,
+        statusCode: response.status,
+        data: payload
+      };
+    }
+    return payload;
+  };
+}

package/dist/runtime/composables/useAuthDiagnostics.d.ts

@@ -0,0 +1,24 @@
+export declare function useAuthDiagnostics(): import("vue").ComputedRef<{
+    provider: "none" | "local" | "remote" | "keycloak";
+    status: "error" | "idle" | "bootstrapping" | "authenticated" | "anonymous";
+    ready: boolean;
+    bootstrapping: boolean;
+    authenticated: boolean;
+    hasAccessToken: boolean;
+    tokenSource: "none" | "storage" | "authenticate" | "reauth" | "keycloak-bridge" | "keycloak-fallback" | "runtime";
+    user: any;
+    permissions: any[];
+    error: any;
+    lastSyncAt: number;
+    lastReadyAt: number;
+    lastAuthenticateAt: number;
+    lastReAuthenticateAt: number;
+    lastBridgeAt: number;
+    lastEnsureReason: string;
+    bridgePath: string;
+    clientSync: {
+        api: "error" | "idle" | "ok" | "missing";
+        client: "error" | "idle" | "ok" | "missing";
+        feathersClient: "error" | "idle" | "ok" | "missing";
+    };
+}>;

package/dist/runtime/composables/useAuthDiagnostics.js

@@ -0,0 +1,25 @@
+import { computed } from "vue";
+import { useAuthRuntime } from "./useAuthRuntime.js";
+export function useAuthDiagnostics() {
+  const auth = useAuthRuntime();
+  return computed(() => ({
+    provider: auth.provider.value,
+    status: auth.status.value,
+    ready: auth.ready.value,
+    bootstrapping: auth.bootstrapping.value,
+    authenticated: auth.authenticated.value,
+    hasAccessToken: Boolean(auth.accessToken.value),
+    tokenSource: auth.tokenSource.value,
+    user: auth.user.value,
+    permissions: auth.permissions.value,
+    error: auth.error.value,
+    lastSyncAt: auth.lastSyncAt.value,
+    lastReadyAt: auth.lastReadyAt.value,
+    lastAuthenticateAt: auth.lastAuthenticateAt.value,
+    lastReAuthenticateAt: auth.lastReAuthenticateAt.value,
+    lastBridgeAt: auth.lastBridgeAt.value,
+    lastEnsureReason: auth.lastEnsureReason.value,
+    bridgePath: auth.bridgePath.value,
+    clientSync: auth.clientSync.value
+  }));
+}

package/dist/runtime/composables/useAuthRuntime.d.ts

@@ -0,0 +1,77 @@
+type AuthProvider = 'keycloak' | 'local' | 'remote' | 'none';
+type AuthStatus = 'idle' | 'bootstrapping' | 'authenticated' | 'anonymous' | 'error';
+type TokenSource = 'none' | 'storage' | 'authenticate' | 'reauth' | 'keycloak-bridge' | 'keycloak-fallback' | 'runtime';
+type AuthSyncState = 'idle' | 'ok' | 'missing' | 'error';
+export declare function useAuthRuntime(): {
+    provider: import("vue").ComputedRef<AuthProvider>;
+    ensureReady: (reason?: string) => Promise<void>;
+    authenticate: (payload: any) => Promise<any>;
+    reAuthenticate: () => Promise<any>;
+    logout: () => Promise<void>;
+    setSession: (payload?: {
+        user?: any;
+        accessToken?: string | null;
+        authenticated?: boolean;
+        permissions?: any[];
+        error?: any;
+    }, source?: TokenSource) => Promise<void>;
+    synchronizeKeycloakSession: (reason?: string, hint?: {
+        token?: string | null;
+        user?: any;
+        tokenParsed?: any;
+        permissions?: any[];
+        loginuser?: string | null;
+    }) => Promise<boolean>;
+    ensureValidatedBearer: (reason?: string) => Promise<boolean>;
+    getAuthorizationHeader: () => Promise<string | null>;
+    getStateSnapshot: () => {
+        provider: AuthProvider;
+        status: AuthStatus;
+        ready: boolean;
+        bootstrapping: boolean;
+        authenticated: boolean;
+        accessToken: string | null;
+        user: any;
+        permissions: any[];
+        tokenSource: TokenSource;
+        error: any;
+        lastSyncAt: number;
+        lastReadyAt: number;
+        lastAuthenticateAt: number;
+        lastReAuthenticateAt: number;
+        lastBridgeAt: number;
+        lastEnsureReason: string;
+        bridgePath: string;
+        clientSync: {
+            api: AuthSyncState;
+            client: AuthSyncState;
+            feathersClient: AuthSyncState;
+        };
+    };
+    status: import("vue").Ref<AuthStatus, AuthStatus>;
+    ready: import("vue").Ref<boolean, boolean>;
+    bootstrapping: import("vue").Ref<boolean, boolean>;
+    authenticated: import("vue").Ref<boolean, boolean>;
+    accessToken: import("vue").Ref<string | null, string | null>;
+    user: import("vue").Ref<any, any>;
+    permissions: import("vue").Ref<any[], any[]>;
+    tokenSource: import("vue").Ref<TokenSource, TokenSource>;
+    error: import("vue").Ref<any, any>;
+    lastSyncAt: import("vue").Ref<number, number>;
+    lastReadyAt: import("vue").Ref<number, number>;
+    lastAuthenticateAt: import("vue").Ref<number, number>;
+    lastReAuthenticateAt: import("vue").Ref<number, number>;
+    lastBridgeAt: import("vue").Ref<number, number>;
+    lastEnsureReason: import("vue").Ref<string, string>;
+    bridgePath: import("vue").Ref<string, string>;
+    clientSync: import("vue").Ref<{
+        api: AuthSyncState;
+        client: AuthSyncState;
+        feathersClient: AuthSyncState;
+    }, {
+        api: AuthSyncState;
+        client: AuthSyncState;
+        feathersClient: AuthSyncState;
+    }>;
+};
+export {};