@better-auth-ui/react 1.6.3 → 1.6.4

package/dist/mutations/settings/change-password-mutation.d.ts

@@ -0,0 +1,78 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type ChangePasswordParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["changePassword"]>[0];
+export type ChangePasswordOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof changePasswordOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for changing the authenticated user's password.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function changePasswordOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<Omit<{
+    token: string | null;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & Record<string, any> & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}, BetterFetchError, ChangePasswordParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for changing the authenticated user's password.
+ *
+ * Wraps `authClient.changePassword` and forwards React Query mutation
+ * options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useChangePassword<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: ChangePasswordOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<Omit<{
+    token: string | null;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & Record<string, any> & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}, BetterFetchError, ChangePasswordParams<TAuthClient>, unknown>;

package/dist/mutations/settings/change-password-mutation.js

@@ -0,0 +1,24 @@
+import { authMutationKeys as e } from "@better-auth-ui/core";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+//#region src/mutations/settings/change-password-mutation.ts
+function r(n) {
+	let r = e.changePassword;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.changePassword({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as changePasswordOptions, i as useChangePassword };

package/dist/mutations/settings/delete-user-mutation.d.ts

@@ -0,0 +1,26 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type DeleteUserParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["deleteUser"]>[0];
+export type DeleteUserOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof deleteUserOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for deleting the authenticated user's account.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function deleteUserOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    success: boolean;
+    message: string;
+}, BetterFetchError, DeleteUserParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for deleting the authenticated user's account.
+ *
+ * Wraps `authClient.deleteUser` and forwards React Query mutation options
+ * such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useDeleteUser<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: DeleteUserOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    success: boolean;
+    message: string;
+}, BetterFetchError, DeleteUserParams<TAuthClient>, unknown>;

package/dist/mutations/settings/delete-user-mutation.js

@@ -0,0 +1,24 @@
+import { authMutationKeys as e } from "@better-auth-ui/core";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+//#region src/mutations/settings/delete-user-mutation.ts
+function r(n) {
+	let r = e.deleteUser;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.deleteUser({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as deleteUserOptions, i as useDeleteUser };

package/dist/mutations/settings/link-social-mutation.d.ts

@@ -0,0 +1,26 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type LinkSocialParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["linkSocial"]>[0];
+export type LinkSocialOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof linkSocialOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for linking a social provider to the current user.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function linkSocialOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    url: string;
+    redirect: boolean;
+}, BetterFetchError, LinkSocialParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for linking a social provider to the current user.
+ *
+ * Wraps `authClient.linkSocial` to initiate a provider redirect and forwards
+ * React Query mutation options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useLinkSocial<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: LinkSocialOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    url: string;
+    redirect: boolean;
+}, BetterFetchError, LinkSocialParams<TAuthClient>, unknown>;

package/dist/mutations/settings/link-social-mutation.js

@@ -0,0 +1,24 @@
+import { authMutationKeys as e } from "@better-auth-ui/core";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+//#region src/mutations/settings/link-social-mutation.ts
+function r(n) {
+	let r = e.linkSocial;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.linkSocial({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as linkSocialOptions, i as useLinkSocial };

package/dist/mutations/settings/revoke-session-mutation.d.ts

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type RevokeSessionParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["revokeSession"]>[0];
+export type RevokeSessionOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof revokeSessionOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for revoking a user session.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function revokeSessionOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, RevokeSessionParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for revoking a user session.
+ *
+ * Wraps `authClient.revokeSession`, refetches the sessions list on success,
+ * and forwards React Query mutation options such as `onSuccess`, `onError`,
+ * and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useRevokeSession<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: RevokeSessionOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, RevokeSessionParams<TAuthClient>, unknown>;

package/dist/mutations/settings/revoke-session-mutation.js

@@ -0,0 +1,29 @@
+import { useListSessions as e } from "../../queries/settings/list-sessions-query.js";
+import { authMutationKeys as t } from "@better-auth-ui/core";
+import { mutationOptions as n, useMutation as r } from "@tanstack/react-query";
+//#region src/mutations/settings/revoke-session-mutation.ts
+function i(e) {
+	let r = t.revokeSession;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.revokeSession({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function a(t, n) {
+	let { refetch: a } = e(t, { refetchOnMount: !1 });
+	return r({
+		...i(t),
+		...n,
+		onSuccess: async (...e) => {
+			await a(), await n?.onSuccess?.(...e);
+		}
+	});
+}
+//#endregion
+export { i as revokeSessionOptions, a as useRevokeSession };

package/dist/mutations/settings/unlink-account-mutation.d.ts

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type UnlinkAccountParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["unlinkAccount"]>[0];
+export type UnlinkAccountOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof unlinkAccountOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for unlinking a social provider from the current user.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function unlinkAccountOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, UnlinkAccountParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for unlinking a social provider from the current user.
+ *
+ * Wraps `authClient.unlinkAccount`, refetches the linked accounts list on
+ * success, and forwards React Query mutation options such as `onSuccess`,
+ * `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useUnlinkAccount<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UnlinkAccountOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, UnlinkAccountParams<TAuthClient>, unknown>;

package/dist/mutations/settings/unlink-account-mutation.js

@@ -0,0 +1,29 @@
+import { useListAccounts as e } from "../../queries/settings/list-accounts-query.js";
+import { authMutationKeys as t } from "@better-auth-ui/core";
+import { mutationOptions as n, useMutation as r } from "@tanstack/react-query";
+//#region src/mutations/settings/unlink-account-mutation.ts
+function i(e) {
+	let r = t.unlinkAccount;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.unlinkAccount({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function a(t, n) {
+	let { refetch: a } = e(t, { refetchOnMount: !1 });
+	return r({
+		...i(t),
+		...n,
+		onSuccess: async (...e) => {
+			await a(), await n?.onSuccess?.(...e);
+		}
+	});
+}
+//#endregion
+export { i as unlinkAccountOptions, a as useUnlinkAccount };

package/dist/mutations/settings/update-user-mutation.d.ts

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type UpdateUserParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["updateUser"]>[0];
+export type UpdateUserOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof updateUserOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for updating the authenticated user's profile.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function updateUserOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, UpdateUserParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for updating the authenticated user's profile.
+ *
+ * Wraps `authClient.updateUser`, optimistically patches the cached session
+ * with the new fields, refetches the session, and forwards React Query
+ * mutation options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useUpdateUser<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UpdateUserOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, UpdateUserParams<TAuthClient>, unknown>;

package/dist/mutations/settings/update-user-mutation.js

@@ -0,0 +1,35 @@
+import { sessionOptions as e, useSession as t } from "../../queries/auth/session-query.js";
+import { authMutationKeys as n } from "@better-auth-ui/core";
+import { mutationOptions as r, useMutation as i, useQueryClient as a } from "@tanstack/react-query";
+//#region src/mutations/settings/update-user-mutation.ts
+function o(e) {
+	let t = n.updateUser;
+	return r({
+		mutationKey: t,
+		mutationFn: (t) => e.updateUser({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function s(n, r) {
+	let { data: s, refetch: c } = t(n, { refetchOnMount: !1 }), l = a();
+	return i({
+		...o(n),
+		...r,
+		onSuccess: async (t, i, ...a) => {
+			s && l.setQueryData(e(n).queryKey, {
+				...s,
+				user: {
+					...s.user,
+					...i
+				}
+			}), c(), await r?.onSuccess?.(t, i, ...a);
+		}
+	});
+}
+//#endregion
+export { o as updateUserOptions, s as useUpdateUser };

package/dist/mutations/username/is-username-available-mutation.d.ts

@@ -0,0 +1,27 @@
+import { BetterFetchError } from 'better-auth/react';
+import { UsernameAuthClient } from '../../lib/auth-client';
+export type IsUsernameAvailableParams<TAuthClient extends UsernameAuthClient> = Parameters<TAuthClient["isUsernameAvailable"]>[0];
+export type IsUsernameAvailableOptions<TAuthClient extends UsernameAuthClient> = Omit<ReturnType<typeof isUsernameAvailableOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for checking username availability.
+ *
+ * Modeled as a mutation because callers typically trigger the check on
+ * user action (debounced input, form submit) rather than on mount.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function isUsernameAvailableOptions<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    available: boolean;
+}, BetterFetchError, IsUsernameAvailableParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for checking whether a username is available.
+ *
+ * Wraps `authClient.isUsernameAvailable` and forwards React Query mutation
+ * options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the username plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useIsUsernameAvailable<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient, options?: IsUsernameAvailableOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    available: boolean;
+}, BetterFetchError, IsUsernameAvailableParams<TAuthClient>, unknown>;

package/dist/mutations/username/is-username-available-mutation.js

@@ -0,0 +1,24 @@
+import { authMutationKeys as e } from "@better-auth-ui/core";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+//#region src/mutations/username/is-username-available-mutation.ts
+function r(n) {
+	let r = e.isUsernameAvailable;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.isUsernameAvailable({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as isUsernameAvailableOptions, i as useIsUsernameAvailable };

package/dist/mutations/username/sign-in-username-mutation.d.ts

@@ -0,0 +1,75 @@
+import { BetterFetchError } from 'better-auth/react';
+import { UsernameAuthClient } from '../../lib/auth-client';
+export type SignInUsernameParams<TAuthClient extends UsernameAuthClient> = Parameters<TAuthClient["signIn"]["username"]>[0];
+export type SignInUsernameOptions<TAuthClient extends UsernameAuthClient> = Omit<ReturnType<typeof signInUsernameOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for username/password sign-in.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function signInUsernameOptions<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<Omit<{
+    token: string;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & {
+        username: string;
+        displayUsername: string;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & {} & {
+        username?: string | null | undefined;
+        displayUsername?: string | null | undefined;
+    }>;
+}, BetterFetchError, SignInUsernameParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for username/password sign-in.
+ *
+ * Wraps `authClient.signIn.username`, resets the session query on success so
+ * the new session is refetched, and forwards React Query mutation options
+ * such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the username plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useSignInUsername<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient, options?: SignInUsernameOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<Omit<{
+    token: string;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & {
+        username: string;
+        displayUsername: string;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & {} & {
+        username?: string | null | undefined;
+        displayUsername?: string | null | undefined;
+    }>;
+}, BetterFetchError, SignInUsernameParams<TAuthClient>, unknown>;

package/dist/mutations/username/sign-in-username-mutation.js

@@ -0,0 +1,29 @@
+import { sessionOptions as e } from "../../queries/auth/session-query.js";
+import { authMutationKeys as t } from "@better-auth-ui/core";
+import { mutationOptions as n, useMutation as r, useQueryClient as i } from "@tanstack/react-query";
+//#region src/mutations/username/sign-in-username-mutation.ts
+function a(e) {
+	let r = t.signIn.username;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.signIn.username({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function o(t, n) {
+	let o = i();
+	return r({
+		...a(t),
+		...n,
+		onSuccess: async (...r) => {
+			o.resetQueries({ queryKey: e(t).queryKey }), await n?.onSuccess?.(...r);
+		}
+	});
+}
+//#endregion
+export { a as signInUsernameOptions, o as useSignInUsername };

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 };