@better-auth-ui/react 1.6.3 → 1.6.5

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

@@ -0,0 +1,71 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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];
+export type SessionOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof sessionOptions<TAuthClient>>, "queryKey" | "queryFn">;
+/**
+ * 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 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"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "getSession"], InferData<TAuthClient["getSession"]>, BetterFetchError>;
+};
+/**
+ * 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 declare const ensureSession: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, params?: SessionParams<TAuthClient>) => Promise<InferData<TAuthClient["getSession"]>>;
+/**
+ * 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 declare const prefetchSession: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, params?: SessionParams<TAuthClient>) => Promise<void>;
+/**
+ * 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 declare const fetchSession: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, params?: SessionParams<TAuthClient>) => Promise<InferData<TAuthClient["getSession"]>>;
+export type UseSessionOptions<TAuthClient extends AuthClient> = SessionOptions<TAuthClient> & SessionParams<TAuthClient>;
+/**
+ * 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 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>;

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

@@ -0,0 +1,30 @@
+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
+			}
+		})
+	});
+}
+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);
+}
+//#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,29 +1,40 @@
-import { QueryKey } from '@tanstack/react-query';
+import { DataTag, QueryKey, UseQueryOptions } from '@tanstack/react-query';
 import { BetterFetchError, BetterFetchOption } from 'better-auth/client';
-export type AuthFn<TData = unknown> = (params: {
+/**
+ * Read-style Better Auth client method (params shape `{ query?, fetchOptions? }`).
+ * Mutation-style endpoints use `AuthMutationFn` / `useAuthMutation` instead.
+ */
+export type AuthQueryFn<TData = unknown> = (params: {
     query?: Record<string, unknown>;
     fetchOptions?: BetterFetchOption;
 }) => Promise<{
     data: TData;
 }>;
-type AuthFnData<TFn> = TFn extends AuthFn<infer TData> ? TData : never;
+export type AuthQueryFnData<TFn> = TFn extends AuthQueryFn<infer TData> ? TData : never;
+/**
+ * Final query key produced by {@link authQueryOptions}: the caller's prefix
+ * followed by `params.query ?? null`.
+ */
+export type AuthQueryKey<TFn extends AuthQueryFn = AuthQueryFn, TPrefix extends QueryKey = QueryKey> = readonly [...TPrefix, NonNullable<Parameters<TFn>[0]>["query"] | null];
+/**
+ * Return type of {@link authQueryOptions}. Named so TypeScript emits
+ * `DataTag<…>` by reference in the `.d.ts`, instead of the raw
+ * `{ [dataTagSymbol]: … }` intersection — which triggers a declaration-emit
+ * bug where `dataTagSymbol` isn't re-imported at the use site and silently
+ * breaks `setQueryData`/`getQueryData` type inference at the consumer.
+ */
+export type AuthQueryOptions<TFn extends AuthQueryFn = AuthQueryFn, TPrefix extends QueryKey = QueryKey> = Omit<UseQueryOptions<AuthQueryFnData<TFn>, BetterFetchError, AuthQueryFnData<TFn>, AuthQueryKey<TFn, TPrefix>>, "queryKey"> & {
+    queryKey: DataTag<AuthQueryKey<TFn, TPrefix>, AuthQueryFnData<TFn>, BetterFetchError>;
+};
 /**
  * Build `queryOptions` for a Better Auth endpoint.
  *
- * Appends `params.query` (or `null`) to the supplied `queryKey` so cache
- * identity tracks endpoint inputs. Wires `throw: true` and the React Query
- * `AbortSignal` into `fetchOptions`.
+ * 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 declare function authQueryOptions<TFn extends AuthFn, const TQueryKey extends QueryKey>(authFn: TFn, queryKey: TQueryKey, params?: Parameters<TFn>[0]): import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<AuthFnData<TFn>, BetterFetchError, AuthFnData<TFn>, readonly unknown[]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<AuthFnData<TFn>, readonly unknown[], never> | undefined;
-} & {
-    queryKey: readonly unknown[] & {
-        [dataTagSymbol]: AuthFnData<TFn>;
-        [dataTagErrorSymbol]: BetterFetchError;
-    };
-};
-export {};
+export declare function authQueryOptions<TFn extends AuthQueryFn, const TPrefix extends QueryKey>(authFn: TFn, queryKey: TPrefix, params?: Parameters<TFn>[0]): AuthQueryOptions<TFn, TPrefix>;

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

@@ -0,0 +1,76 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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];
+export type ListDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient> = Omit<ReturnType<typeof listDeviceSessionsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+/**
+ * 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 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;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "listDeviceSessions", 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>;
+};
+/**
+ * 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 declare const ensureListDeviceSessions: <TAuthClient extends MultiSessionAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListDeviceSessionsParams<TAuthClient>) => Promise<InferData<TAuthClient["multiSession"]["listDeviceSessions"]>>;
+/**
+ * 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 declare const prefetchListDeviceSessions: <TAuthClient extends MultiSessionAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListDeviceSessionsParams<TAuthClient>) => Promise<void>;
+/**
+ * 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 declare const fetchListDeviceSessions: <TAuthClient extends MultiSessionAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListDeviceSessionsParams<TAuthClient>) => Promise<InferData<TAuthClient["multiSession"]["listDeviceSessions"]>>;
+export type UseListDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient> = ListDeviceSessionsOptions<TAuthClient> & ListDeviceSessionsParams<TAuthClient>;
+/**
+ * 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 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>;

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

@@ -0,0 +1,31 @@
+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
+			}
+		})
+	});
+}
+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);
+}
+//#endregion
+export { o as ensureListDeviceSessions, c as fetchListDeviceSessions, a as listDeviceSessionsOptions, s as prefetchListDeviceSessions, l as useListDeviceSessions };

package/dist/queries/passkey/list-passkeys-query.d.ts

@@ -0,0 +1,74 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { InferData, PasskeyAuthClient } from '../../lib/auth-client';
+export type ListPasskeysData<TAuthClient extends PasskeyAuthClient> = InferData<TAuthClient["passkey"]["listUserPasskeys"]>;
+export type ListPasskeysParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["passkey"]["listUserPasskeys"]>[0];
+export type ListPasskey<TAuthClient extends PasskeyAuthClient = PasskeyAuthClient> = NonNullable<ListPasskeysData<TAuthClient>>[number];
+export type ListPasskeysOptions<TAuthClient extends PasskeyAuthClient> = Omit<ReturnType<typeof listPasskeysOptions<TAuthClient>>, "queryKey" | "queryFn">;
+/**
+ * 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 declare function listPasskeysOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListPasskeysParams<TAuthClient>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<InferData<TAuthClient["passkey"]["listUserPasskeys"]>, BetterFetchError, InferData<TAuthClient["passkey"]["listUserPasskeys"]>, readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<InferData<TAuthClient["passkey"]["listUserPasskeys"]>, readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null] & {
+        [dataTagSymbol]: InferData<TAuthClient["passkey"]["listUserPasskeys"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null], InferData<TAuthClient["passkey"]["listUserPasskeys"]>, BetterFetchError>;
+};
+/**
+ * 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 declare const ensureListPasskeys: <TAuthClient extends PasskeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListPasskeysParams<TAuthClient>) => Promise<InferData<TAuthClient["passkey"]["listUserPasskeys"]>>;
+/**
+ * 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 declare const prefetchListPasskeys: <TAuthClient extends PasskeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListPasskeysParams<TAuthClient>) => Promise<void>;
+/**
+ * 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 declare const fetchListPasskeys: <TAuthClient extends PasskeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListPasskeysParams<TAuthClient>) => Promise<InferData<TAuthClient["passkey"]["listUserPasskeys"]>>;
+export type UseListPasskeysOptions<TAuthClient extends PasskeyAuthClient> = ListPasskeysOptions<TAuthClient> & ListPasskeysParams<TAuthClient>;
+/**
+ * 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 declare function useListPasskeys<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: UseListPasskeysOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["passkey"]["listUserPasskeys"]>>, BetterFetchError>;

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

@@ -0,0 +1,31 @@
+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
+			}
+		})
+	});
+}
+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);
+}
+//#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

@@ -0,0 +1,85 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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>>;
+export type AccountInfoOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof accountInfoOptions<TAuthClient>>, "queryKey" | "queryFn">;
+/**
+ * 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 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", {
+        accountId?: string | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "accountInfo", {
+        accountId?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: InferData<TAuthClient["accountInfo"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "accountInfo", {
+        accountId?: string | undefined;
+    } | null], InferData<TAuthClient["accountInfo"]>, BetterFetchError>;
+};
+/**
+ * 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 declare const ensureAccountInfo: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: AccountInfoParams<TAuthClient>) => Promise<InferData<TAuthClient["accountInfo"]>>;
+/**
+ * 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 declare const prefetchAccountInfo: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: AccountInfoParams<TAuthClient>) => Promise<void>;
+/**
+ * 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 declare const fetchAccountInfo: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: AccountInfoParams<TAuthClient>) => Promise<InferData<TAuthClient["accountInfo"]>>;
+export type UseAccountInfoOptions<TAuthClient extends AuthClient> = AccountInfoOptions<TAuthClient> & AccountInfoParams<TAuthClient>;
+/**
+ * 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 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>;

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

@@ -0,0 +1,31 @@
+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
+			}
+		})
+	});
+}
+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);
+}
+//#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

@@ -0,0 +1,76 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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];
+export type ListAccountsOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof listAccountsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+/**
+ * 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 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"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null], InferData<TAuthClient["listAccounts"]>, BetterFetchError>;
+};
+/**
+ * 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 declare const ensureListAccounts: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListAccountsParams<TAuthClient>) => Promise<InferData<TAuthClient["listAccounts"]>>;
+/**
+ * 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 declare const prefetchListAccounts: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListAccountsParams<TAuthClient>) => Promise<void>;
+/**
+ * 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 declare const fetchListAccounts: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListAccountsParams<TAuthClient>) => Promise<InferData<TAuthClient["listAccounts"]>>;
+export type UseListAccountsOptions<TAuthClient extends AuthClient> = ListAccountsOptions<TAuthClient> & ListAccountsParams<TAuthClient>;
+/**
+ * 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 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>;

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

@@ -0,0 +1,31 @@
+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
+			}
+		})
+	});
+}
+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);
+}
+//#endregion
+export { o as ensureListAccounts, c as fetchListAccounts, a as listAccountsOptions, s as prefetchListAccounts, l as useListAccounts };