@better-auth-ui/react 1.6.8 → 1.6.9

package/dist/plugins/captcha-plugin.js

@@ -1,29 +1,34 @@
 "use client";
-import { useFetchOptions as e } from "../components/auth/fetch-options-provider.js";
-import { useAuthPlugin as t } from "../hooks/use-auth-plugin.js";
-import { createAuthPlugin as n } from "@better-auth-ui/core";
-import { useCallback as r, useEffect as i } from "react";
-import { jsx as a } from "react/jsx-runtime";
-//#region src/plugins/captcha-plugin.tsx
-function o() {
-	let { render: n } = t(s), { setFetchOptions: o, registerReset: c } = e(), l = r((e) => {
-		o({ headers: { "x-captcha-response": e } });
-	}, [o]), u = r(() => {
-		o(void 0);
-	}, [o]), d = r((e) => {
-		c(e);
-	}, [c]);
-	return i(() => () => {
-		o(void 0), c(null);
-	}, [o, c]), /* @__PURE__ */ a(n, {
-		setToken: l,
-		clearToken: u,
-		setReset: d
-	});
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createAuthPlugin } from "@better-auth-ui/core";
+import { useCallback, useEffect } from "react";
+import { useFetchOptions } from "../components/auth/fetch-options-provider";
+import { useAuthPlugin } from "../hooks/use-auth-plugin";
+function CaptchaWidget() {
+    const { render: Render } = useAuthPlugin(captchaPlugin);
+    const { setFetchOptions, registerReset } = useFetchOptions();
+    const setToken = useCallback((token) => {
+        setFetchOptions({ headers: { "x-captcha-response": token } });
+    }, [setFetchOptions]);
+    const clearToken = useCallback(() => {
+        setFetchOptions(undefined);
+    }, [setFetchOptions]);
+    const setReset = useCallback((reset) => {
+        registerReset(reset);
+    }, [registerReset]);
+    useEffect(() => {
+        return () => {
+            setFetchOptions(undefined);
+            registerReset(null);
+        };
+    }, [setFetchOptions, registerReset]);
+    return (_jsx(Render, { setToken: setToken, clearToken: clearToken, setReset: setReset }));
 }
-var s = n("captcha", ({ render: e }) => ({
-	render: e,
-	captchaComponent: /* @__PURE__ */ a(o, {})
+/**
+ * Provider-agnostic captcha plugin. Forwards the resolved token via the
+ * `x-captcha-response` header on Better Auth requests.
+ */
+export const captchaPlugin = createAuthPlugin("captcha", ({ render }) => ({
+    render,
+    captchaComponent: _jsx(CaptchaWidget, {})
 }));
-//#endregion
-export { s as captchaPlugin };

package/dist/plugins.d.ts

@@ -1 +1 @@
-export * from './plugins/captcha-plugin';
+export * from "./plugins/captcha-plugin";

package/dist/plugins.js

@@ -1,3 +1,2 @@
 "use client";
-import { captchaPlugin as e } from "./plugins/captcha-plugin.js";
-export { e as captchaPlugin };
+export * from "./plugins/captcha-plugin";

package/dist/queries/api-key/list-api-keys-query.d.ts

@@ -1,18 +1,22 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { BetterFetchError } from 'better-auth/react';
-import { ApiKeyAuthClient, InferData } from '../../lib/auth-client';
-export type ListApiKeysData<TAuthClient extends ApiKeyAuthClient> = InferData<TAuthClient["apiKey"]["list"]>;
-export type ListApiKeysParams<TAuthClient extends ApiKeyAuthClient> = Parameters<TAuthClient["apiKey"]["list"]>[0];
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { ApiKeyAuthClient, InferData } from "../../lib/auth-client";
+export type ListApiKeysData<TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient> = InferData<TAuthClient["apiKey"]["list"]>;
+export type ListApiKeysParams<TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient> = Parameters<TAuthClient["apiKey"]["list"]>[0];
 export type ListedApiKey<TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient> = NonNullable<ListApiKeysData<TAuthClient>>["apiKeys"][number];
-export type ListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> = Omit<ReturnType<typeof listApiKeysOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export type ListApiKeysOptions<TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient> = Omit<ReturnType<typeof listApiKeysOptions<TAuthClient>>, "queryKey" | "queryFn">;
 /**
  * Query options factory for the current user's API keys.
  *
+ * Shares a query key with the server-side `listApiKeysOptions` from
+ * `@better-auth-ui/react/server`, so SSR-hydrated data is reused from the
+ * cache without an immediate refetch.
+ *
  * @param authClient - The Better Auth client with the API key plugin.
  * @param userId - The current signed-in user's ID. Used for cache partitioning.
  * @param params - Parameters forwarded to `authClient.apiKey.list`.
  */
-export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListApiKeysParams<TAuthClient>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<InferData<TAuthClient["apiKey"]["list"]>, BetterFetchError, InferData<TAuthClient["apiKey"]["list"]>, readonly ["auth", "user", string | undefined, "listApiKeys", {
+export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListApiKeysParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["apiKey"]["list"]>, BetterFetchError, InferData<TAuthClient["apiKey"]["list"]>, readonly ["auth", "user", string | undefined, "apiKey", "list", {
     configId?: string | undefined;
     organizationId?: string | undefined;
     limit?: unknown;
@@ -20,7 +24,7 @@ export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>
     sortBy?: string | undefined;
     sortDirection?: "asc" | "desc" | undefined;
 } | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<InferData<TAuthClient["apiKey"]["list"]>, readonly ["auth", "user", string | undefined, "listApiKeys", {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["apiKey"]["list"]>, readonly ["auth", "user", string | undefined, "apiKey", "list", {
         configId?: string | undefined;
         organizationId?: string | undefined;
         limit?: unknown;
@@ -29,7 +33,7 @@ export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>
         sortDirection?: "asc" | "desc" | undefined;
     } | null], never> | undefined;
 } & {
-    queryKey: readonly ["auth", "user", string | undefined, "listApiKeys", {
+    queryKey: readonly ["auth", "user", string | undefined, "apiKey", "list", {
         configId?: string | undefined;
         organizationId?: string | undefined;
         limit?: unknown;
@@ -41,7 +45,7 @@ export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>
         [dataTagErrorSymbol]: BetterFetchError;
     };
 }) & {
-    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listApiKeys", {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "apiKey", "list", {
         configId?: string | undefined;
         organizationId?: string | undefined;
         limit?: unknown;
@@ -57,8 +61,13 @@ export type UseListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> = ListAp
 /**
  * Subscribe to the current user's API keys via TanStack Query.
  *
+ * Shares a query key with the server-side `listApiKeysOptions`, so
+ * SSR-hydrated data is reused from the cache without an immediate refetch.
+ * The query is gated on a signed-in user; while the session is loading or
+ * absent, the underlying `queryFn` is replaced with `skipToken`.
+ *
  * @param authClient - The Better Auth client with the API key plugin.
  * @param options - `apiKey.list` params merged with `useQuery` options.
  * @param queryClient - Optional custom `QueryClient`.
  */
-export declare function useListApiKeys<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, options?: UseListApiKeysOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["apiKey"]["list"]>>, BetterFetchError>;
+export declare function useListApiKeys<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, options?: UseListApiKeysOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["apiKey"]["list"]>>, BetterFetchError>;

package/dist/queries/api-key/list-api-keys-query.js

@@ -1,31 +1,54 @@
-import { useSession as e } from "../auth/session-query.js";
-import { authQueryKeys as t } from "@better-auth-ui/core";
-import { queryOptions as n, skipToken as r, useQuery as i } from "@tanstack/react-query";
-//#region src/queries/api-key/list-api-keys-query.ts
-function a(e, r, i) {
-	return n({
-		queryKey: t.listApiKeys(r, i?.query),
-		queryFn: ({ signal: t }) => e.apiKey.list({
-			...i,
-			fetchOptions: {
-				...i?.fetchOptions,
-				signal: t,
-				throw: !0
-			}
-		})
-	});
+import { apiKeyQueryKeys } from "@better-auth-ui/core/plugins";
+import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
+import { useSession } from "../auth/session-query";
+/**
+ * Query options factory for the current user's API keys.
+ *
+ * Shares a query key with the server-side `listApiKeysOptions` from
+ * `@better-auth-ui/react/server`, so SSR-hydrated data is reused from the
+ * cache without an immediate refetch.
+ *
+ * @param authClient - The Better Auth client with the API key plugin.
+ * @param userId - The current signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.apiKey.list`.
+ */
+export function listApiKeysOptions(authClient, userId, params) {
+    const queryKey = apiKeyQueryKeys.list(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: ({ signal }) => authClient.apiKey.list({
+            ...params,
+            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        })
+    });
+    return options;
 }
-var o = (e, t, n, r) => e.ensureQueryData(a(t, n, r)), s = (e, t, n, r) => e.prefetchQuery(a(t, n, r)), c = (e, t, n, r) => e.fetchQuery(a(t, n, r));
-function l(t, n = {}, o) {
-	let { data: s } = e(t, void 0, o), c = s?.user.id, { query: l, fetchOptions: u, ...d } = n, f = a(t, c, {
-		query: l,
-		fetchOptions: u
-	});
-	return i({
-		...d,
-		...f,
-		queryFn: c ? f.queryFn : r
-	}, o);
+export const ensureListApiKeys = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listApiKeysOptions(authClient, userId, params));
+export const prefetchListApiKeys = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listApiKeysOptions(authClient, userId, params));
+export const fetchListApiKeys = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listApiKeysOptions(authClient, userId, params));
+/**
+ * Subscribe to the current user's API keys via TanStack Query.
+ *
+ * Shares a query key with the server-side `listApiKeysOptions`, so
+ * SSR-hydrated data is reused from the cache without an immediate refetch.
+ * The query is gated on a signed-in user; while the session is loading or
+ * absent, the underlying `queryFn` is replaced with `skipToken`.
+ *
+ * @param authClient - The Better Auth client with the API key plugin.
+ * @param options - `apiKey.list` params merged with `useQuery` options.
+ * @param queryClient - Optional custom `QueryClient`.
+ */
+export function useListApiKeys(authClient, options = {}, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { query, fetchOptions, ...queryOptionsRest } = options;
+    const baseOptions = listApiKeysOptions(authClient, userId, {
+        query,
+        fetchOptions
+    });
+    return useQuery({
+        ...queryOptionsRest,
+        ...baseOptions,
+        queryFn: userId ? baseOptions.queryFn : skipToken
+    }, queryClient);
 }
-//#endregion
-export { o as ensureListApiKeys, c as fetchListApiKeys, a as listApiKeysOptions, s as prefetchListApiKeys, l as useListApiKeys };

package/dist/queries/auth/session-query.d.ts

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { BetterFetchError } from 'better-auth/react';
-import { AuthClient, InferData } from '../../lib/auth-client';
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { AuthClient, InferData } from "../../lib/auth-client";
 export type SessionData<TAuthClient extends AuthClient = AuthClient> = InferData<TAuthClient["getSession"]>;
 export type Session<TAuthClient extends AuthClient = AuthClient> = NonNullable<SessionData<TAuthClient>>;
 export type SessionParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["getSession"]>[0];
@@ -14,8 +14,8 @@ export type SessionOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typ
  * @param authClient - The Better Auth client.
  * @param params - Parameters forwarded to `authClient.getSession`.
  */
-export declare function sessionOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, params?: SessionParams<TAuthClient>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<InferData<TAuthClient["getSession"]>, BetterFetchError, InferData<TAuthClient["getSession"]>, readonly ["auth", "getSession"]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<InferData<TAuthClient["getSession"]>, readonly ["auth", "getSession"], never> | undefined;
+export declare function sessionOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, params?: SessionParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["getSession"]>, BetterFetchError, InferData<TAuthClient["getSession"]>, readonly ["auth", "getSession"]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["getSession"]>, readonly ["auth", "getSession"], never> | undefined;
 } & {
     queryKey: readonly ["auth", "getSession"] & {
         [dataTagSymbol]: InferData<TAuthClient["getSession"]>;
@@ -68,4 +68,4 @@ export type UseSessionOptions<TAuthClient extends AuthClient> = SessionOptions<T
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useSession<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseSessionOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["getSession"]>>, BetterFetchError>;
+export declare function useSession<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseSessionOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["getSession"]>>, BetterFetchError>;

package/dist/queries/auth/session-query.js

@@ -1,30 +1,72 @@
-import { authQueryKeys as e } from "@better-auth-ui/core";
-import { queryOptions as t, useQuery as n } from "@tanstack/react-query";
-//#region src/queries/auth/session-query.ts
-function r(n, r) {
-	let i = e.session;
-	return t({
-		queryKey: i,
-		queryFn: ({ signal: e }) => n.getSession({
-			...r,
-			fetchOptions: {
-				...r?.fetchOptions,
-				signal: e,
-				throw: !0
-			}
-		})
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { queryOptions, useQuery } from "@tanstack/react-query";
+/**
+ * Query options factory for the current session.
+ *
+ * Shares a query key with the server-side `sessionOptions` so that data
+ * prefetched during SSR hydrates seamlessly into the client cache.
+ *
+ * @param authClient - The Better Auth client.
+ * @param params - Parameters forwarded to `authClient.getSession`.
+ */
+export function sessionOptions(authClient, params) {
+    const queryKey = authQueryKeys.session;
+    const options = queryOptions({
+        queryKey,
+        queryFn: ({ signal }) => authClient.getSession({
+            ...params,
+            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        })
+    });
+    return options;
 }
-var i = (e, t, n) => e.ensureQueryData(r(t, n)), a = (e, t, n) => e.prefetchQuery(r(t, n)), o = (e, t, n) => e.fetchQuery(r(t, n));
-function s(e, t = {}, i) {
-	let { query: a, fetchOptions: o, ...s } = t;
-	return n({
-		...r(e, {
-			query: a,
-			fetchOptions: o
-		}),
-		...s
-	}, i);
+/**
+ * Get the current session from the query cache, calling `fetchSession` under
+ * the hood if no cached entry exists. Resolves with the session data, making
+ * it ideal for loaders or `beforeLoad` guards.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param params - Parameters forwarded to `authClient.getSession`.
+ */
+export const ensureSession = (queryClient, authClient, params) => queryClient.ensureQueryData(sessionOptions(authClient, params));
+/**
+ * Prefetch the current session into the query cache. Behaves like
+ * `fetchSession`, but does not throw on error and does not return the data —
+ * use this to warm the cache without blocking navigation.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param params - Parameters forwarded to `authClient.getSession`.
+ */
+export const prefetchSession = (queryClient, authClient, params) => queryClient.prefetchQuery(sessionOptions(authClient, params));
+/**
+ * Fetch and cache the current session, resolving with the data or throwing
+ * on error. If a cached entry exists and is neither invalidated nor older
+ * than `staleTime`, the cached value is returned without a network call;
+ * otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param params - Parameters forwarded to `authClient.getSession`.
+ */
+export const fetchSession = (queryClient, authClient, params) => queryClient.fetchQuery(sessionOptions(authClient, params));
+/**
+ * Subscribe to the current session via TanStack Query.
+ *
+ * Shares a query key with the server-side `sessionOptions`, so SSR-hydrated
+ * session data is reused from the cache without an immediate refetch.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - `getSession` params (`query`, `fetchOptions`) merged
+ *   with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
+ * @param queryClient - Optional custom `QueryClient`. Defaults to the client
+ *   from the nearest `QueryClientProvider`.
+ */
+export function useSession(authClient, options = {}, queryClient) {
+    const { query, fetchOptions, ...queryOptions } = options;
+    return useQuery({
+        ...sessionOptions(authClient, { query, fetchOptions }),
+        ...queryOptions
+    }, queryClient);
 }
-//#endregion
-export { i as ensureSession, o as fetchSession, a as prefetchSession, r as sessionOptions, s as useSession };

package/dist/queries/auth-query-options.d.ts

@@ -1,5 +1,5 @@
-import { DataTag, QueryKey, UseQueryOptions } from '@tanstack/react-query';
-import { BetterFetchError, BetterFetchOption } from 'better-auth/client';
+import { type DataTag, type QueryKey, type UseQueryOptions } from "@tanstack/react-query";
+import type { BetterFetchError, BetterFetchOption } from "better-auth/client";
 /**
  * Read-style Better Auth client method (params shape `{ query?, fetchOptions? }`).
  * Mutation-style endpoints use `AuthMutationFn` / `useAuthMutation` instead.

package/dist/queries/auth-query-options.js

@@ -1,17 +1,21 @@
-import { queryOptions as e } from "@tanstack/react-query";
-//#region src/queries/auth-query-options.ts
-function t(t, n, r) {
-	return e({
-		queryKey: [...n, r?.query ?? null],
-		queryFn: ({ signal: e }) => t({
-			...r,
-			fetchOptions: {
-				...r?.fetchOptions,
-				signal: e,
-				throw: !0
-			}
-		})
-	});
+import { queryOptions } from "@tanstack/react-query";
+/**
+ * Build `queryOptions` for a Better Auth endpoint.
+ *
+ * Injects React Query's `signal` and `throw: true` into `fetchOptions` so the
+ * request is cancelled on unmount and errors surface as `BetterFetchError`
+ * instead of `{ data, error }`.
+ *
+ * @param authFn - Better Auth client method (e.g. `authClient.getSession`).
+ * @param queryKey - Scope prefix for the key. `params.query` is appended automatically.
+ * @param params - Parameters forwarded to `authFn`.
+ */
+export function authQueryOptions(authFn, queryKey, params) {
+    return queryOptions({
+        queryKey: [...queryKey, params?.query ?? null],
+        queryFn: ({ signal }) => authFn({
+            ...params,
+            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        })
+    });
 }
-//#endregion
-export { t as authQueryOptions };

package/dist/queries/multi-session/list-device-sessions-query.d.ts

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { BetterFetchError } from 'better-auth/react';
-import { InferData, MultiSessionAuthClient } from '../../lib/auth-client';
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { InferData, MultiSessionAuthClient } from "../../lib/auth-client";
 export type ListDeviceSessionsData<TAuthClient extends MultiSessionAuthClient = MultiSessionAuthClient> = InferData<TAuthClient["multiSession"]["listDeviceSessions"]>;
 export type ListDeviceSession<TAuthClient extends MultiSessionAuthClient = MultiSessionAuthClient> = NonNullable<ListDeviceSessionsData<TAuthClient>>[number];
 export type ListDeviceSessionsParams<TAuthClient extends MultiSessionAuthClient> = Parameters<TAuthClient["multiSession"]["listDeviceSessions"]>[0];
@@ -12,15 +12,15 @@ export type ListDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient
  * @param userId - The current signed-in user's ID. Used for cache partitioning.
  * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
  */
-export declare function listDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListDeviceSessionsParams<TAuthClient>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<InferData<TAuthClient["multiSession"]["listDeviceSessions"]>, BetterFetchError, InferData<TAuthClient["multiSession"]["listDeviceSessions"]>, readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<InferData<TAuthClient["multiSession"]["listDeviceSessions"]>, readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null], never> | undefined;
+export declare function listDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListDeviceSessionsParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["multiSession"]["listDeviceSessions"]>, BetterFetchError, InferData<TAuthClient["multiSession"]["listDeviceSessions"]>, readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["multiSession"]["listDeviceSessions"]>, readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null], never> | undefined;
 } & {
-    queryKey: readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null] & {
+    queryKey: readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null] & {
         [dataTagSymbol]: InferData<TAuthClient["multiSession"]["listDeviceSessions"]>;
         [dataTagErrorSymbol]: BetterFetchError;
     };
 }) & {
-    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null], InferData<TAuthClient["multiSession"]["listDeviceSessions"]>, BetterFetchError>;
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null], InferData<TAuthClient["multiSession"]["listDeviceSessions"]>, BetterFetchError>;
 };
 /**
  * Get the current user's device sessions from the query cache, calling
@@ -73,4 +73,4 @@ export type UseListDeviceSessionsOptions<TAuthClient extends MultiSessionAuthCli
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useListDeviceSessions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: UseListDeviceSessionsOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["multiSession"]["listDeviceSessions"]>>, BetterFetchError>;
+export declare function useListDeviceSessions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: UseListDeviceSessionsOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["multiSession"]["listDeviceSessions"]>>, BetterFetchError>;

package/dist/queries/multi-session/list-device-sessions-query.js

@@ -1,31 +1,85 @@
-import { useSession as e } from "../auth/session-query.js";
-import { authQueryKeys as t } from "@better-auth-ui/core";
-import { queryOptions as n, skipToken as r, useQuery as i } from "@tanstack/react-query";
-//#region src/queries/multi-session/list-device-sessions-query.ts
-function a(e, r, i) {
-	return n({
-		queryKey: t.listDeviceSessions(r, i?.query),
-		queryFn: ({ signal: t }) => e.multiSession.listDeviceSessions({
-			...i,
-			fetchOptions: {
-				...i?.fetchOptions,
-				signal: t,
-				throw: !0
-			}
-		})
-	});
+import { multiSessionQueryKeys } from "@better-auth-ui/core/plugins";
+import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
+import { useSession } from "../auth/session-query";
+/**
+ * Query options factory for the current user's device sessions.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param userId - The current signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
+ */
+export function listDeviceSessionsOptions(authClient, userId, params) {
+    const queryKey = multiSessionQueryKeys.list(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: ({ signal }) => authClient.multiSession.listDeviceSessions({
+            ...params,
+            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        })
+    });
+    return options;
 }
-var o = (e, t, n, r) => e.ensureQueryData(a(t, n, r)), s = (e, t, n, r) => e.prefetchQuery(a(t, n, r)), c = (e, t, n, r) => e.fetchQuery(a(t, n, r));
-function l(t, n = {}, o) {
-	let { data: s } = e(t, void 0, o), c = s?.user.id, { query: l, fetchOptions: u, ...d } = n, f = a(t, c, {
-		query: l,
-		fetchOptions: u
-	});
-	return i({
-		...d,
-		...f,
-		queryFn: c ? f.queryFn : r
-	}, o);
+/**
+ * Get the current user's device sessions from the query cache, calling
+ * `fetchListDeviceSessions` under the hood if no cached entry exists.
+ * Resolves with the device session list, making it ideal for loaders or
+ * `beforeLoad` guards.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
+ */
+export const ensureListDeviceSessions = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listDeviceSessionsOptions(authClient, userId, params));
+/**
+ * Prefetch the current user's device sessions into the query cache. Behaves
+ * like `fetchListDeviceSessions`, but does not throw on error and does not
+ * return the data — use this to warm the cache without blocking navigation.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
+ */
+export const prefetchListDeviceSessions = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listDeviceSessionsOptions(authClient, userId, params));
+/**
+ * Fetch and cache the current user's device sessions, resolving with the
+ * data or throwing on error. If a cached entry exists and is neither
+ * invalidated nor older than `staleTime`, the cached value is returned
+ * without a network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
+ */
+export const fetchListDeviceSessions = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listDeviceSessionsOptions(authClient, userId, params));
+/**
+ * Subscribe to the current user's device sessions (multi-session account
+ * switcher) via TanStack Query.
+ *
+ * Shares a query key with the server-side `listDeviceSessionsOptions`, so
+ * SSR-hydrated data is reused from the cache without an immediate refetch.
+ * The query is gated on a signed-in user; while the session is loading or
+ * absent, the underlying `queryFn` is replaced with `skipToken`.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param options - `listDeviceSessions` params (`query`, `fetchOptions`)
+ *   merged with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
+ * @param queryClient - Optional custom `QueryClient`. Defaults to the client
+ *   from the nearest `QueryClientProvider`.
+ */
+export function useListDeviceSessions(authClient, options = {}, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { query, fetchOptions, ...queryOptions } = options;
+    const baseOptions = listDeviceSessionsOptions(authClient, userId, {
+        query,
+        fetchOptions
+    });
+    return useQuery({
+        ...queryOptions,
+        ...baseOptions,
+        queryFn: userId ? baseOptions.queryFn : skipToken
+    }, queryClient);
 }
-//#endregion
-export { o as ensureListDeviceSessions, c as fetchListDeviceSessions, a as listDeviceSessionsOptions, s as prefetchListDeviceSessions, l as useListDeviceSessions };

package/dist/queries/organization/active-organization-query.d.ts

@@ -0,0 +1,39 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+import type { FullOrganizationParams } from "./full-organization-query";
+import type { ListOrganization } from "./list-organizations-query";
+export type ActiveOrganizationData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListOrganization<TAuthClient>;
+export type ActiveOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = FullOrganizationParams<TAuthClient>;
+export type ActiveOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof activeOrganizationOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function activeOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<ActiveOrganizationData<TAuthClient>, BetterFetchError, ActiveOrganizationData<TAuthClient>, readonly ["auth", "user", string | undefined, "organization", "active", {
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+    membersLimit?: string | number | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<ActiveOrganizationData<TAuthClient>, readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: ActiveOrganizationData<TAuthClient>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], ActiveOrganizationData<TAuthClient>, BetterFetchError>;
+};
+export declare const ensureActiveOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>) => Promise<ActiveOrganizationData<TAuthClient>>;
+export declare const prefetchActiveOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>) => Promise<void>;
+export declare const fetchActiveOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>) => Promise<ActiveOrganizationData<TAuthClient>>;
+export type UseActiveOrganizationOptions<TAuthClient extends OrganizationAuthClient> = ActiveOrganizationOptions<TAuthClient> & ActiveOrganizationParams<TAuthClient>;
+export declare function useActiveOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseActiveOrganizationOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<ActiveOrganizationData<TAuthClient>>, BetterFetchError>;