@better-auth-ui/react 1.6.2 → 1.6.4

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

@@ -0,0 +1,60 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { MultiSessionAuthServer } from '../../../lib/auth-server';
+export type ListDeviceSessionsData<TAuth extends MultiSessionAuthServer> = Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>;
+export type ListDeviceSession<TAuth extends MultiSessionAuthServer = MultiSessionAuthServer> = NonNullable<ListDeviceSessionsData<TAuth>>[number];
+export type ListDeviceSessionsParams<TAuth extends MultiSessionAuthServer> = Parameters<TAuth["api"]["listDeviceSessions"]>[0];
+/**
+ * Query options factory for the current user's device sessions.
+ *
+ * @param auth - The Better Auth server instance with the multi-session plugin.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listDeviceSessionsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
+ */
+export declare function listDeviceSessionsOptions<TAuth extends MultiSessionAuthServer>(auth: TAuth, userId: string, params: ListDeviceSessionsParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["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]: Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError>;
+};
+/**
+ * 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 suitable for reading
+ * directly in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
+ */
+export declare const ensureListDeviceSessions: <TAuth extends MultiSessionAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListDeviceSessionsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["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 when you only need the value to be available
+ * after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
+ */
+export declare const prefetchListDeviceSessions: <TAuth extends MultiSessionAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListDeviceSessionsParams<TAuth>) => 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 used for SSR hydration.
+ * @param auth - The Better Auth server instance with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
+ */
+export declare const fetchListDeviceSessions: <TAuth extends MultiSessionAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListDeviceSessionsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>>;

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

@@ -0,0 +1,12 @@
+import { authQueryKeys as e } from "@better-auth-ui/core";
+import { queryOptions as t } from "@tanstack/react-query";
+//#region src/server/queries/multi-session/list-device-sessions-query.ts
+function n(n, r, i) {
+	return t({
+		queryKey: e.listDeviceSessions(r, i?.query),
+		queryFn: () => n.api.listDeviceSessions(i)
+	});
+}
+var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
+//#endregion
+export { r as ensureListDeviceSessions, a as fetchListDeviceSessions, n as listDeviceSessionsOptions, i as prefetchListDeviceSessions };

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

@@ -0,0 +1,60 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { PasskeyAuthServer } from '../../../lib/auth-server';
+export type ListPasskeysData<TAuth extends PasskeyAuthServer> = Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>;
+export type ListPasskeysParams<TAuth extends PasskeyAuthServer> = Parameters<TAuth["api"]["listPasskeys"]>[0];
+export type ListPasskey<TAuth extends PasskeyAuthServer = PasskeyAuthServer> = NonNullable<ListPasskeysData<TAuth>>[number];
+/**
+ * Query options factory for the current user's passkeys.
+ *
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listPasskeysOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export declare function listPasskeysOptions<TAuth extends PasskeyAuthServer>(auth: TAuth, userId: string, params: ListPasskeysParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, APIError>;
+};
+/**
+ * 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 suitable for reading directly in a server
+ * component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export declare const ensureListPasskeys: <TAuth extends PasskeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListPasskeysParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>>;
+/**
+ * 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 when you only need the value to be available after
+ * hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export declare const prefetchListPasskeys: <TAuth extends PasskeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListPasskeysParams<TAuth>) => 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 used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export declare const fetchListPasskeys: <TAuth extends PasskeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListPasskeysParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>>;

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

@@ -0,0 +1,12 @@
+import { authQueryKeys as e } from "@better-auth-ui/core";
+import { queryOptions as t } from "@tanstack/react-query";
+//#region src/server/queries/passkey/list-passkeys-query.ts
+function n(n, r, i) {
+	return t({
+		queryKey: e.listPasskeys(r, i?.query),
+		queryFn: () => n.api.listPasskeys(i)
+	});
+}
+var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
+//#endregion
+export { r as ensureListPasskeys, a as fetchListPasskeys, n as listPasskeysOptions, i as prefetchListPasskeys };

package/dist/server/queries/settings/account-info-query.d.ts

@@ -0,0 +1,68 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { AuthServer } from '../../../lib/auth-server';
+export type AccountInfoData<TAuth extends AuthServer = AuthServer> = Awaited<ReturnType<TAuth["api"]["accountInfo"]>>;
+export type AccountInfoParams<TAuth extends AuthServer> = Parameters<TAuth["api"]["accountInfo"]>[0];
+export type AccountInfo<TAuth extends AuthServer = AuthServer> = NonNullable<AccountInfoData<TAuth>>;
+/**
+ * Query options factory for provider-specific account info.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `accountInfoOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export declare function accountInfoOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: AccountInfoParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, APIError, Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, readonly ["auth", "user", string | undefined, "accountInfo", {
+    accountId?: string | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["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]: Awaited<ReturnType<TAuth["api"]["accountInfo"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "accountInfo", {
+        accountId?: string | undefined;
+    } | null], Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, APIError>;
+};
+/**
+ * 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 suitable for reading directly
+ * in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export declare const ensureAccountInfo: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: AccountInfoParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["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 when you only need the value to be
+ * available after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export declare const prefetchAccountInfo: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: AccountInfoParams<TAuth>) => 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 used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export declare const fetchAccountInfo: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: AccountInfoParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["accountInfo"]>>>;

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

@@ -0,0 +1,12 @@
+import { authQueryKeys as e } from "@better-auth-ui/core";
+import { queryOptions as t } from "@tanstack/react-query";
+//#region src/server/queries/settings/account-info-query.ts
+function n(n, r, i) {
+	return t({
+		queryKey: e.accountInfo(r, i?.query),
+		queryFn: () => n.api.accountInfo(i)
+	});
+}
+var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
+//#endregion
+export { n as accountInfoOptions, r as ensureAccountInfo, a as fetchAccountInfo, i as prefetchAccountInfo };

package/dist/server/queries/settings/list-accounts-query.d.ts

@@ -0,0 +1,60 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { AuthServer } from '../../../lib/auth-server';
+export type ListAccountsData<TAuth extends AuthServer = AuthServer> = Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>;
+export type ListAccountsParams<TAuth extends AuthServer> = Parameters<TAuth["api"]["listUserAccounts"]>[0];
+export type ListAccount<TAuth extends AuthServer = AuthServer> = NonNullable<ListAccountsData<TAuth>>[number];
+/**
+ * Query options factory for the current user's linked social accounts.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listAccountsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export declare function listAccountsOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: ListAccountsParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, APIError>;
+};
+/**
+ * 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 suitable for reading directly
+ * in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export declare const ensureListAccounts: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListAccountsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>>;
+/**
+ * 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 when you only need the value to be
+ * available after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export declare const prefetchListAccounts: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListAccountsParams<TAuth>) => 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 used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export declare const fetchListAccounts: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListAccountsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>>;

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

@@ -0,0 +1,12 @@
+import { authQueryKeys as e } from "@better-auth-ui/core";
+import { queryOptions as t } from "@tanstack/react-query";
+//#region src/server/queries/settings/list-accounts-query.ts
+function n(n, r, i) {
+	return t({
+		queryKey: e.listAccounts(r, i?.query),
+		queryFn: () => n.api.listUserAccounts(i)
+	});
+}
+var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
+//#endregion
+export { r as ensureListAccounts, a as fetchListAccounts, n as listAccountsOptions, i as prefetchListAccounts };

package/dist/server/queries/settings/list-sessions-query.d.ts

@@ -0,0 +1,60 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { AuthServer } from '../../../lib/auth-server';
+export type ListSessionsData<TAuth extends AuthServer = AuthServer> = Awaited<ReturnType<TAuth["api"]["listSessions"]>>;
+export type ListSessionsParams<TAuth extends AuthServer> = Parameters<TAuth["api"]["listSessions"]>[0];
+export type ListSession<TAuth extends AuthServer = AuthServer> = NonNullable<ListSessionsData<TAuth>>[number];
+/**
+ * Query options factory for the current user's active sessions.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listSessionsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listSessions`.
+ */
+export declare function listSessionsOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: ListSessionsParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listSessions"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listSessions"]>>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["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]: Awaited<ReturnType<TAuth["api"]["listSessions"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listSessions"]>>, APIError>;
+};
+/**
+ * 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 suitable for reading directly in a server
+ * component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listSessions`.
+ */
+export declare const ensureListSessions: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListSessionsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listSessions"]>>>;
+/**
+ * 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 when you only need the value to be available after
+ * hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listSessions`.
+ */
+export declare const prefetchListSessions: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListSessionsParams<TAuth>) => Promise<void>;
+/**
+ * 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 used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listSessions`.
+ */
+export declare const fetchListSessions: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListSessionsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listSessions"]>>>;

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

@@ -0,0 +1,12 @@
+import { authQueryKeys as e } from "@better-auth-ui/core";
+import { queryOptions as t } from "@tanstack/react-query";
+//#region src/server/queries/settings/list-sessions-query.ts
+function n(n, r, i) {
+	return t({
+		queryKey: e.listSessions(r, i?.query),
+		queryFn: () => n.api.listSessions(i)
+	});
+}
+var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
+//#endregion
+export { r as ensureListSessions, a as fetchListSessions, n as listSessionsOptions, i as prefetchListSessions };

package/dist/server.d.ts

@@ -0,0 +1,7 @@
+export type * from './lib/auth-server';
+export * from './server/queries/auth/session-query';
+export * from './server/queries/multi-session/list-device-sessions-query';
+export * from './server/queries/passkey/list-passkeys-query';
+export * from './server/queries/settings/account-info-query';
+export * from './server/queries/settings/list-accounts-query';
+export * from './server/queries/settings/list-sessions-query';

package/dist/server.js

@@ -0,0 +1,7 @@
+import { ensureSession as e, fetchSession as t, prefetchSession as n, sessionOptions as r } from "./server/queries/auth/session-query.js";
+import { ensureListDeviceSessions as i, fetchListDeviceSessions as a, listDeviceSessionsOptions as o, prefetchListDeviceSessions as s } from "./server/queries/multi-session/list-device-sessions-query.js";
+import { ensureListPasskeys as c, fetchListPasskeys as l, listPasskeysOptions as u, prefetchListPasskeys as d } from "./server/queries/passkey/list-passkeys-query.js";
+import { accountInfoOptions as f, ensureAccountInfo as p, fetchAccountInfo as m, prefetchAccountInfo as h } from "./server/queries/settings/account-info-query.js";
+import { ensureListAccounts as g, fetchListAccounts as _, listAccountsOptions as v, prefetchListAccounts as y } from "./server/queries/settings/list-accounts-query.js";
+import { ensureListSessions as b, fetchListSessions as x, listSessionsOptions as S, prefetchListSessions as C } from "./server/queries/settings/list-sessions-query.js";
+export { f as accountInfoOptions, p as ensureAccountInfo, g as ensureListAccounts, i as ensureListDeviceSessions, c as ensureListPasskeys, b as ensureListSessions, e as ensureSession, m as fetchAccountInfo, _ as fetchListAccounts, a as fetchListDeviceSessions, l as fetchListPasskeys, x as fetchListSessions, t as fetchSession, v as listAccountsOptions, o as listDeviceSessionsOptions, u as listPasskeysOptions, S as listSessionsOptions, h as prefetchAccountInfo, y as prefetchListAccounts, s as prefetchListDeviceSessions, d as prefetchListPasskeys, C as prefetchListSessions, n as prefetchSession, r as sessionOptions };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@better-auth-ui/react",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "type": "module",
   "scripts": {
     "build": "vite build",
-    "dev": "tsc --watch",
-    "email": "email dev --dir src/components/email -p 9000",
+    "dev": "vite build --watch",
+    "email": "email dev --dir src/components/auth/email -p 9000",
     "test": "vitest"
   },
   "files": [
@@ -19,46 +19,48 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./core": {
-      "types": "./dist/core.d.ts",
-      "import": "./dist/core.js"
+    "./email": {
+      "types": "./dist/email.d.ts",
+      "import": "./dist/email.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     }
   },
   "devDependencies": {
+    "@better-auth/passkey": "^1.6.9",
     "@react-email/components": "^1.0.12",
     "@react-email/preview-server": "^5.2.10",
-    "@tanstack/react-query": "^5.99.0",
+    "@tanstack/react-query": "^5.100.8",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.5.2",
     "@types/react": "^19.2.14",
     "@vitejs/plugin-react": "^6.0.1",
-    "@vitest/browser-playwright": "^4.1.4",
-    "@better-auth/passkey": "^1.6.5",
-    "better-auth": "^1.6.5",
+    "@vitest/browser-playwright": "^4.1.5",
+    "better-auth": "^1.6.9",
     "clsx": "^2.1.1",
     "playwright": "^1.59.1",
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
-    "react-email": "^6.0.0",
+    "react-email": "^6.0.5",
     "tailwind-merge": "^3.5.0",
-    "tailwindcss": "^4.2.2",
-    "vitest": "^4.1.4",
-    "zod": "^4.3.6"
-  },
-  "dependencies": {
-    "@better-auth-ui/core": "*"
+    "tailwindcss": "^4.2.4",
+    "vitest": "^4.1.5",
+    "zod": "^4.4.2"
   },
   "peerDependencies": {
+    "@better-auth-ui/core": "*",
+    "@better-auth/passkey": ">=1.6.9",
     "@react-email/components": ">=1.0.12",
-    "@tanstack/react-query": ">=5.99.0",
-    "@better-auth/passkey": ">=1.6.5",
-    "better-auth": ">=1.6.5",
+    "@tanstack/react-query": ">=5.100.8",
+    "better-auth": ">=1.6.9",
     "clsx": ">=2.0.0",
     "react": ">=19.2.5",
     "react-dom": ">=19.2.5",
     "tailwind-merge": ">=3.5.0",
-    "tailwindcss": ">=4.2.2",
-    "zod": ">=4.3.0"
+    "tailwindcss": ">=4.2.4",
+    "zod": ">=4.4.2"
   },
   "repository": {
     "type": "git",

package/src/components/auth/auth-provider.tsx

@@ -1,30 +1,57 @@
 "use client"
 
-import { deepmerge, defaultAuthConfig } from "@better-auth-ui/core"
+import {
+  type AdditionalField,
+  type AuthConfig,
+  type DeepPartial,
+  deepmerge,
+  defaultAuthConfig
+} from "@better-auth-ui/core"
 import {
   QueryClient,
   QueryClientContext,
   QueryClientProvider
 } from "@tanstack/react-query"
-import { type PropsWithChildren, useContext } from "react"
+import {
+  createContext,
+  type PropsWithChildren,
+  type ReactNode,
+  useContext
+} from "react"
 
-import type { AnyAuthClient } from "../../lib/auth-client"
-import type { AnyAuthConfig, AuthConfig } from "../../lib/auth-config"
-import { AuthContext } from "../../lib/auth-context"
+import type { AuthClient } from "../../lib/auth-client"
 
-const fallbackQueryClient = new QueryClient()
+const AuthContext = createContext<AuthConfig | undefined>(undefined)
 
-const baseAuthConfig: AnyAuthConfig = {
-  ...defaultAuthConfig,
-  Link: (props) => <a {...props} />
+const fallbackQueryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 5000
+    }
+  }
+})
+
+declare module "@better-auth-ui/core" {
+  interface AuthConfig {
+    /**
+     * The auth client to use for the authentication context.
+     * @remarks `AuthClient`
+     */
+    authClient: AuthClient
+  }
+
+  /** Widen `AdditionalField.label` to `ReactNode` in the React package. */
+  interface AdditionalFieldRegister {
+    label: ReactNode
+  }
 }
 
-export type AuthProviderProps = PropsWithChildren<AnyAuthConfig> & {
-  authClient: AnyAuthClient
+export type AuthProviderProps<TAuthClient = AuthClient> = PropsWithChildren<
+  DeepPartial<AuthConfig>
+> & {
+  authClient: TAuthClient
   navigate: (options: { to: string; replace?: boolean }) => void
-  /**
-   * TanStack QueryClient to use for your application's queries
-   */
+  /** TanStack QueryClient to use for your application's queries */
   queryClient?: QueryClient
 }
 
@@ -43,33 +70,69 @@ export function AuthProvider({
   queryClient,
   ...config
 }: AuthProviderProps) {
-  const contextQueryClient = useContext(QueryClientContext)
-  const resolvedQueryClient =
-    queryClient || contextQueryClient || fallbackQueryClient
-
-  const mergedConfig = deepmerge(baseAuthConfig, config) as AuthConfig
+  const mergedConfig = deepmerge(defaultAuthConfig, {
+    ...config,
+    viewPaths: {
+      auth: {
+        ...defaultAuthConfig.viewPaths.auth,
+        ...config.viewPaths?.auth
+      },
+      settings: {
+        ...defaultAuthConfig.viewPaths.settings,
+        ...config.viewPaths?.settings
+      }
+    }
+  } as AuthConfig)
 
   mergedConfig.redirectTo =
     (typeof window !== "undefined" &&
       new URLSearchParams(window.location.search).get("redirectTo")?.trim()) ||
     mergedConfig.redirectTo
 
+  // Merge plugin-contributed `additionalFields` with user-supplied ones.
+  // Plugin order is preserved; user-supplied entries with the same `name`
+  // override the plugin contribution.
+  const fieldsByName = new Map<string, AdditionalField>()
+  for (const plugin of mergedConfig.plugins ?? []) {
+    for (const field of plugin.additionalFields ?? []) {
+      fieldsByName.set(field.name, field)
+    }
+  }
+  for (const field of mergedConfig.additionalFields ?? []) {
+    fieldsByName.set(field.name, field)
+  }
+  mergedConfig.additionalFields = Array.from(fieldsByName.values())
+
+  const contextQueryClient = useContext(QueryClientContext)
+
+  if (contextQueryClient) {
+    return (
+      <AuthContext.Provider value={mergedConfig}>
+        {children}
+      </AuthContext.Provider>
+    )
+  }
+
   return (
-    <AuthContext.Provider value={mergedConfig}>
-      <QueryClientProvider client={resolvedQueryClient}>
+    <QueryClientProvider client={queryClient || fallbackQueryClient}>
+      <AuthContext.Provider value={mergedConfig}>
         {children}
-      </QueryClientProvider>
-    </AuthContext.Provider>
+      </AuthContext.Provider>
+    </QueryClientProvider>
   )
 }
 
 /**
  * Accesses the current authentication configuration from AuthContext.
  *
+ * UI packages widen the plugin type globally via the `Register` interface
+ * (see module augmentation in `@better-auth-ui/heroui`), so callers don't
+ * need to pass a generic.
+ *
  * @returns The merged authentication configuration provided by AuthProvider.
  * @throws If no AuthProvider is present in the component tree.
  */
-export function useAuth() {
+export function useAuth(): AuthConfig {
   const context = useContext(AuthContext)
 
   if (!context) {