@better-auth-ui/react 1.6.8 → 1.6.9

package/dist/queries/passkey/list-passkeys-query.js

@@ -1,31 +1,83 @@
-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/passkey/list-passkeys-query.ts
-function a(e, r, i) {
-	return n({
-		queryKey: t.listPasskeys(r, i?.query),
-		queryFn: ({ signal: t }) => e.passkey.listUserPasskeys({
-			...i,
-			fetchOptions: {
-				...i?.fetchOptions,
-				signal: t,
-				throw: !0
-			}
-		})
-	});
+import { passkeyQueryKeys } 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 passkeys.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ * @param userId - The current signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
+ */
+export function listPasskeysOptions(authClient, userId, params) {
+    const queryKey = passkeyQueryKeys.list(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: ({ signal }) => authClient.passkey.listUserPasskeys({
+            ...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 passkeys from the query cache, calling
+ * `fetchListPasskeys` under the hood if no cached entry exists. Resolves
+ * with the passkey list, making it ideal for loaders or `beforeLoad` guards.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
+ */
+export const ensureListPasskeys = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listPasskeysOptions(authClient, userId, params));
+/**
+ * Prefetch the current user's passkeys into the query cache. Behaves like
+ * `fetchListPasskeys`, 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 passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
+ */
+export const prefetchListPasskeys = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listPasskeysOptions(authClient, userId, params));
+/**
+ * Fetch and cache the current user's passkeys, 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 passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
+ */
+export const fetchListPasskeys = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listPasskeysOptions(authClient, userId, params));
+/**
+ * Subscribe to the current user's passkeys via TanStack Query.
+ *
+ * Shares a query key with the server-side `listPasskeysOptions`, 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 passkey plugin.
+ * @param options - `listPasskeys` 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 useListPasskeys(authClient, options = {}, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { query, fetchOptions, ...queryOptions } = options;
+    const baseOptions = listPasskeysOptions(authClient, userId, {
+        query,
+        fetchOptions
+    });
+    return useQuery({
+        ...queryOptions,
+        ...baseOptions,
+        queryFn: userId ? baseOptions.queryFn : skipToken
+    }, queryClient);
 }
-//#endregion
-export { o as ensureListPasskeys, c as fetchListPasskeys, a as listPasskeysOptions, s as prefetchListPasskeys, l as useListPasskeys };

package/dist/queries/settings/account-info-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 AccountInfoData<TAuthClient extends AuthClient> = InferData<TAuthClient["accountInfo"]>;
 export type AccountInfoParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["accountInfo"]>[0];
 export type AccountInfo<TAuthClient extends AuthClient = AuthClient> = NonNullable<AccountInfoData<TAuthClient>>;
@@ -12,10 +12,10 @@ export type AccountInfoOptions<TAuthClient extends AuthClient> = Omit<ReturnType
  * @param userId - The current signed-in user's ID. Used for cache partitioning.
  * @param params - Parameters forwarded to `authClient.accountInfo`.
  */
-export declare function accountInfoOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: AccountInfoParams<TAuthClient>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<InferData<TAuthClient["accountInfo"]>, BetterFetchError, InferData<TAuthClient["accountInfo"]>, readonly ["auth", "user", string | undefined, "accountInfo", {
+export declare function accountInfoOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: AccountInfoParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["accountInfo"]>, BetterFetchError, InferData<TAuthClient["accountInfo"]>, readonly ["auth", "user", string | undefined, "accountInfo", {
     accountId?: string | undefined;
 } | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<InferData<TAuthClient["accountInfo"]>, readonly ["auth", "user", string | undefined, "accountInfo", {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["accountInfo"]>, readonly ["auth", "user", string | undefined, "accountInfo", {
         accountId?: string | undefined;
     } | null], never> | undefined;
 } & {
@@ -82,4 +82,4 @@ export type UseAccountInfoOptions<TAuthClient extends AuthClient> = AccountInfoO
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useAccountInfo<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseAccountInfoOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["accountInfo"]>>, BetterFetchError>;
+export declare function useAccountInfo<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseAccountInfoOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["accountInfo"]>>, BetterFetchError>;

package/dist/queries/settings/account-info-query.js

@@ -1,31 +1,87 @@
-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/settings/account-info-query.ts
-function a(e, r, i) {
-	return n({
-		queryKey: t.accountInfo(r, i?.query),
-		queryFn: ({ signal: t }) => e.accountInfo({
-			...i,
-			fetchOptions: {
-				...i?.fetchOptions,
-				signal: t,
-				throw: !0
-			}
-		})
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
+import { useSession } from "../auth/session-query";
+/**
+ * Query options factory for provider-specific account info.
+ *
+ * @param authClient - The Better Auth client.
+ * @param userId - The current signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.accountInfo`.
+ */
+export function accountInfoOptions(authClient, userId, params) {
+    const queryKey = authQueryKeys.accountInfo(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: ({ signal }) => authClient.accountInfo({
+            ...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
-	}), p = !!(c && l?.accountId);
-	return i({
-		...d,
-		...f,
-		queryFn: p ? f.queryFn : r
-	}, o);
+/**
+ * Get the current user's provider-specific account info from the query
+ * cache, calling `fetchAccountInfo` under the hood if no cached entry
+ * exists. Resolves with the data, making it ideal for loaders or
+ * `beforeLoad` guards.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.accountInfo`.
+ */
+export const ensureAccountInfo = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(accountInfoOptions(authClient, userId, params));
+/**
+ * Prefetch the current user's provider-specific account info into the query
+ * cache. Behaves like `fetchAccountInfo`, 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 userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.accountInfo`.
+ */
+export const prefetchAccountInfo = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(accountInfoOptions(authClient, userId, params));
+/**
+ * Fetch and cache the current user's provider-specific account info,
+ * 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 userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.accountInfo`.
+ */
+export const fetchAccountInfo = (queryClient, authClient, userId, params) => queryClient.fetchQuery(accountInfoOptions(authClient, userId, params));
+/**
+ * Subscribe to provider-specific info for a linked account via TanStack Query.
+ *
+ * Shares a query key with the server-side `accountInfoOptions`, so
+ * SSR-hydrated data is reused from the cache without an immediate refetch.
+ * The query is gated on both a signed-in user and a resolved `accountId`;
+ * until both are present, the underlying `queryFn` is replaced with
+ * `skipToken`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - `accountInfo` 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 useAccountInfo(authClient, options = {}, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { query, fetchOptions, ...queryOptions } = options;
+    const baseOptions = accountInfoOptions(authClient, userId, {
+        query,
+        fetchOptions
+    });
+    const canFetch = Boolean(userId && query?.accountId);
+    return useQuery({
+        ...queryOptions,
+        ...baseOptions,
+        queryFn: canFetch ? baseOptions.queryFn : skipToken
+    }, queryClient);
 }
-//#endregion
-export { a as accountInfoOptions, o as ensureAccountInfo, c as fetchAccountInfo, s as prefetchAccountInfo, l as useAccountInfo };

package/dist/queries/settings/list-accounts-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 ListAccountsData<TAuthClient extends AuthClient> = InferData<TAuthClient["listAccounts"]>;
 export type ListAccountsParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["listAccounts"]>[0];
 export type ListAccount<TAuthClient extends AuthClient = AuthClient> = NonNullable<ListAccountsData<TAuthClient>>[number];
@@ -12,8 +12,8 @@ export type ListAccountsOptions<TAuthClient extends AuthClient> = Omit<ReturnTyp
  * @param userId - The current signed-in user's ID. Used for cache partitioning.
  * @param params - Parameters forwarded to `authClient.listAccounts`.
  */
-export declare function listAccountsOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListAccountsParams<TAuthClient>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<InferData<TAuthClient["listAccounts"]>, BetterFetchError, InferData<TAuthClient["listAccounts"]>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<InferData<TAuthClient["listAccounts"]>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null], never> | undefined;
+export declare function listAccountsOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListAccountsParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["listAccounts"]>, BetterFetchError, InferData<TAuthClient["listAccounts"]>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["listAccounts"]>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null], never> | undefined;
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null] & {
         [dataTagSymbol]: InferData<TAuthClient["listAccounts"]>;
@@ -73,4 +73,4 @@ export type UseListAccountsOptions<TAuthClient extends AuthClient> = ListAccount
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useListAccounts<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListAccountsOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["listAccounts"]>>, BetterFetchError>;
+export declare function useListAccounts<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListAccountsOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["listAccounts"]>>, BetterFetchError>;

package/dist/queries/settings/list-accounts-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/settings/list-accounts-query.ts
-function a(e, r, i) {
-	return n({
-		queryKey: t.listAccounts(r, i?.query),
-		queryFn: ({ signal: t }) => e.listAccounts({
-			...i,
-			fetchOptions: {
-				...i?.fetchOptions,
-				signal: t,
-				throw: !0
-			}
-		})
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
+import { useSession } from "../auth/session-query";
+/**
+ * Query options factory for a user's linked social accounts.
+ *
+ * @param authClient - The Better Auth client.
+ * @param userId - The current signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listAccounts`.
+ */
+export function listAccountsOptions(authClient, userId, params) {
+    const queryKey = authQueryKeys.listAccounts(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: ({ signal }) => authClient.listAccounts({
+            ...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 linked social accounts from the query cache,
+ * calling `fetchListAccounts` under the hood if no cached entry exists.
+ * Resolves with the account list, making it ideal for loaders or
+ * `beforeLoad` guards.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listAccounts`.
+ */
+export const ensureListAccounts = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listAccountsOptions(authClient, userId, params));
+/**
+ * Prefetch the current user's linked social accounts into the query cache.
+ * Behaves like `fetchListAccounts`, 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 userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listAccounts`.
+ */
+export const prefetchListAccounts = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listAccountsOptions(authClient, userId, params));
+/**
+ * Fetch and cache the current user's linked social accounts, 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 userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listAccounts`.
+ */
+export const fetchListAccounts = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listAccountsOptions(authClient, userId, params));
+/**
+ * Subscribe to the current user's linked social accounts via TanStack Query.
+ *
+ * Shares a query key with the server-side `listAccountsOptions`, 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.
+ * @param options - `listAccounts` 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 useListAccounts(authClient, options = {}, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { query, fetchOptions, ...queryOptions } = options;
+    const baseOptions = listAccountsOptions(authClient, userId, {
+        query,
+        fetchOptions
+    });
+    return useQuery({
+        ...queryOptions,
+        ...baseOptions,
+        queryFn: userId ? baseOptions.queryFn : skipToken
+    }, queryClient);
 }
-//#endregion
-export { o as ensureListAccounts, c as fetchListAccounts, a as listAccountsOptions, s as prefetchListAccounts, l as useListAccounts };

package/dist/queries/settings/list-sessions-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 ListSessionsData<TAuthClient extends AuthClient> = InferData<TAuthClient["listSessions"]>;
 export type ListSessionsParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["listSessions"]>[0];
 export type ListSession<TAuthClient extends AuthClient = AuthClient> = NonNullable<ListSessionsData<TAuthClient>>[number];
@@ -12,8 +12,8 @@ export type ListSessionsOptions<TAuthClient extends AuthClient> = Omit<ReturnTyp
  * @param userId - The current signed-in user's ID. Used for cache partitioning.
  * @param params - Parameters forwarded to `authClient.listSessions`.
  */
-export declare function listSessionsOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListSessionsParams<TAuthClient>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<InferData<TAuthClient["listSessions"]>, BetterFetchError, InferData<TAuthClient["listSessions"]>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<InferData<TAuthClient["listSessions"]>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null], never> | undefined;
+export declare function listSessionsOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListSessionsParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["listSessions"]>, BetterFetchError, InferData<TAuthClient["listSessions"]>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["listSessions"]>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null], never> | undefined;
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null] & {
         [dataTagSymbol]: InferData<TAuthClient["listSessions"]>;
@@ -71,4 +71,4 @@ export type UseListSessionsOptions<TAuthClient extends AuthClient> = ListSession
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useListSessions<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListSessionsOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["listSessions"]>>, BetterFetchError>;
+export declare function useListSessions<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListSessionsOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["listSessions"]>>, BetterFetchError>;

package/dist/queries/settings/list-sessions-query.js

@@ -1,31 +1,83 @@
-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/settings/list-sessions-query.ts
-function a(e, r, i) {
-	return n({
-		queryKey: t.listSessions(r, i?.query),
-		queryFn: ({ signal: t }) => e.listSessions({
-			...i,
-			fetchOptions: {
-				...i?.fetchOptions,
-				signal: t,
-				throw: !0
-			}
-		})
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
+import { useSession } from "../auth/session-query";
+/**
+ * Query options factory for the current user's active sessions.
+ *
+ * @param authClient - The Better Auth client.
+ * @param userId - The current signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listSessions`.
+ */
+export function listSessionsOptions(authClient, userId, params) {
+    const queryKey = authQueryKeys.listSessions(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: ({ signal }) => authClient.listSessions({
+            ...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 active sessions from the query cache, calling
+ * `fetchListSessions` under the hood if no cached entry exists. Resolves
+ * with the session list, making it ideal for loaders or `beforeLoad` guards.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listSessions`.
+ */
+export const ensureListSessions = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listSessionsOptions(authClient, userId, params));
+/**
+ * Prefetch the current user's active sessions into the query cache. Behaves
+ * like `fetchListSessions`, 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 userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listSessions`.
+ */
+export const prefetchListSessions = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listSessionsOptions(authClient, userId, params));
+/**
+ * Fetch and cache the current user's active 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.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listSessions`.
+ */
+export const fetchListSessions = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listSessionsOptions(authClient, userId, params));
+/**
+ * Subscribe to the current user's active sessions via TanStack Query.
+ *
+ * Shares a query key with the server-side `listSessionsOptions`, 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.
+ * @param options - `listSessions` 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 useListSessions(authClient, options = {}, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { query, fetchOptions, ...queryOptions } = options;
+    const baseOptions = listSessionsOptions(authClient, userId, {
+        query,
+        fetchOptions
+    });
+    return useQuery({
+        ...queryOptions,
+        ...baseOptions,
+        queryFn: userId ? baseOptions.queryFn : skipToken
+    }, queryClient);
 }
-//#endregion
-export { o as ensureListSessions, c as fetchListSessions, a as listSessionsOptions, s as prefetchListSessions, l as useListSessions };

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

@@ -0,0 +1,83 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { ApiKeyAuthServer } from "../../../lib/auth-server";
+export type ListApiKeysData<TAuth extends ApiKeyAuthServer = ApiKeyAuthServer> = Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>;
+export type ListedApiKey<TAuth extends ApiKeyAuthServer = ApiKeyAuthServer> = NonNullable<ListApiKeysData<TAuth>>["apiKeys"][number];
+export type ListApiKeysParams<TAuth extends ApiKeyAuthServer = ApiKeyAuthServer> = Parameters<TAuth["api"]["listApiKeys"]>[0];
+/**
+ * Query options factory for the current user's API keys on the server.
+ *
+ * Uses the same query key as the client-side `listApiKeysOptions` so that data
+ * fetched during SSR hydrates seamlessly into the client's React Query cache.
+ *
+ * @param auth - The Better Auth server instance with the API key plugin.
+ * @param userId - The signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listApiKeys`.
+ */
+export declare function listApiKeysOptions<TAuth extends ApiKeyAuthServer>(auth: TAuth, userId: string, params: ListApiKeysParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>, readonly ["auth", "user", string | undefined, "apiKey", "list", {
+    configId?: string | undefined;
+    organizationId?: string | undefined;
+    limit?: unknown;
+    offset?: unknown;
+    sortBy?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>, readonly ["auth", "user", string | undefined, "apiKey", "list", {
+        configId?: string | undefined;
+        organizationId?: string | undefined;
+        limit?: unknown;
+        offset?: unknown;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "apiKey", "list", {
+        configId?: string | undefined;
+        organizationId?: string | undefined;
+        limit?: unknown;
+        offset?: unknown;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+    } | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "apiKey", "list", {
+        configId?: string | undefined;
+        organizationId?: string | undefined;
+        limit?: unknown;
+        offset?: unknown;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+    } | null], Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>, APIError>;
+};
+/**
+ * Get the current user's API keys from the query cache, calling
+ * `fetchListApiKeys` under the hood if no cached entry exists.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the API key plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listApiKeys`.
+ */
+export declare const ensureListApiKeys: <TAuth extends ApiKeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListApiKeysParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>>;
+/**
+ * Prefetch the current user's API keys into the query cache.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the API key plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listApiKeys`.
+ */
+export declare const prefetchListApiKeys: <TAuth extends ApiKeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListApiKeysParams<TAuth>) => Promise<void>;
+/**
+ * Fetch and cache the current user's API keys, resolving with the data or
+ * throwing on error.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the API key plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listApiKeys`.
+ */
+export declare const fetchListApiKeys: <TAuth extends ApiKeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListApiKeysParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>>;