@better-auth-ui/react 1.6.3 → 1.6.4

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

@@ -0,0 +1,177 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { InferData, MultiSessionAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+
+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 function listDeviceSessionsOptions<
+  TAuthClient extends MultiSessionAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListDeviceSessionsParams<TAuthClient>
+) {
+  type TData = ListDeviceSessionsData<TAuthClient>
+  const queryKey = authQueryKeys.listDeviceSessions(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.multiSession.listDeviceSessions({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, 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 const ensureListDeviceSessions = <
+  TAuthClient extends MultiSessionAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListDeviceSessionsParams<TAuthClient>
+) =>
+  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 = <
+  TAuthClient extends MultiSessionAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListDeviceSessionsParams<TAuthClient>
+) =>
+  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 = <
+  TAuthClient extends MultiSessionAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListDeviceSessionsParams<TAuthClient>
+) =>
+  queryClient.fetchQuery(listDeviceSessionsOptions(authClient, userId, params))
+
+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 function useListDeviceSessions<
+  TAuthClient extends MultiSessionAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListDeviceSessionsOptions<TAuthClient> = {},
+  queryClient?: 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
+  )
+}

package/src/queries/passkey/list-passkeys-query.ts

@@ -0,0 +1,154 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { InferData, PasskeyAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+
+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 function listPasskeysOptions<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListPasskeysParams<TAuthClient>
+) {
+  type TData = ListPasskeysData<TAuthClient>
+  const queryKey = authQueryKeys.listPasskeys(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.passkey.listUserPasskeys({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, 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 const ensureListPasskeys = <TAuthClient extends PasskeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListPasskeysParams<TAuthClient>
+) =>
+  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 = <TAuthClient extends PasskeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListPasskeysParams<TAuthClient>
+) => 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 = <TAuthClient extends PasskeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListPasskeysParams<TAuthClient>
+) => queryClient.fetchQuery(listPasskeysOptions(authClient, userId, params))
+
+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 function useListPasskeys<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  options: UseListPasskeysOptions<TAuthClient> = {},
+  queryClient?: 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
+  )
+}

package/src/queries/settings/account-info-query.ts

@@ -0,0 +1,158 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { AuthClient, InferData } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+
+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 function accountInfoOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: AccountInfoParams<TAuthClient>
+) {
+  type TData = AccountInfoData<TAuthClient>
+  const queryKey = authQueryKeys.accountInfo(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.accountInfo({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, 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 const ensureAccountInfo = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: AccountInfoParams<TAuthClient>
+) => 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 = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: AccountInfoParams<TAuthClient>
+) => 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 = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: AccountInfoParams<TAuthClient>
+) => queryClient.fetchQuery(accountInfoOptions(authClient, userId, params))
+
+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 function useAccountInfo<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options: UseAccountInfoOptions<TAuthClient> = {},
+  queryClient?: 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
+  )
+}

package/src/queries/settings/list-accounts-query.ts

@@ -0,0 +1,156 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { AuthClient, InferData } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+
+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 function listAccountsOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListAccountsParams<TAuthClient>
+) {
+  type TData = ListAccountsData<TAuthClient>
+  const queryKey = authQueryKeys.listAccounts(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.listAccounts({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, 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 const ensureListAccounts = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListAccountsParams<TAuthClient>
+) =>
+  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 = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListAccountsParams<TAuthClient>
+) => 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 = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListAccountsParams<TAuthClient>
+) => queryClient.fetchQuery(listAccountsOptions(authClient, userId, params))
+
+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 function useListAccounts<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options: UseListAccountsOptions<TAuthClient> = {},
+  queryClient?: 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
+  )
+}