@better-auth-ui/react 1.6.7 → 1.6.9

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

@@ -1,24 +1,33 @@
-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
-			}
-		})
-	});
+import { authMutationKeys } from "@better-auth-ui/core";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+/**
+ * Mutation options factory for linking a social provider to the current user.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function linkSocialOptions(authClient) {
+    const mutationKey = authMutationKeys.linkSocial;
+    const mutationFn = (params) => authClient.linkSocial({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-function i(e, t) {
-	return n({
-		...r(e),
-		...t
-	});
+/**
+ * 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 function useLinkSocial(authClient, options) {
+    return useMutation({
+        ...linkSocialOptions(authClient),
+        ...options
+    });
 }
-//#endregion
-export { r as linkSocialOptions, i as useLinkSocial };

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

@@ -1,25 +1,25 @@
-import { BetterFetchError } from 'better-auth/react';
-import { AuthClient } from '../../lib/auth-client';
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { 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">;
+export type RevokeSessionOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof revokeSessionOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * 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<{
+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`.
+ * On success, `MutationInvalidator` awaits invalidation of the sessions
+ * list (see `meta.awaits`).
  *
  * @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<{
+export declare function useRevokeSession<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: RevokeSessionOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
     status: boolean;
 }, BetterFetchError, RevokeSessionParams<TAuthClient>, unknown>;

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

@@ -1,29 +1,39 @@
-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
-			}
-		})
-	});
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+/**
+ * Mutation options factory for revoking a user session.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function revokeSessionOptions(authClient) {
+    const mutationKey = authMutationKeys.revokeSession;
+    const mutationFn = (params) => authClient.revokeSession({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-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);
-		}
-	});
+/**
+ * Create a mutation for revoking a user session.
+ *
+ * On success, `MutationInvalidator` awaits invalidation of the sessions
+ * list (see `meta.awaits`).
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useRevokeSession(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...revokeSessionOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [authQueryKeys.listSessions(userId)]
+        }
+    }, queryClient);
 }
-//#endregion
-export { i as revokeSessionOptions, a as useRevokeSession };

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

@@ -1,25 +1,25 @@
-import { BetterFetchError } from 'better-auth/react';
-import { AuthClient } from '../../lib/auth-client';
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { 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">;
+export type UnlinkAccountOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof unlinkAccountOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * 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<{
+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`.
+ * On success, `MutationInvalidator` awaits invalidation of the linked
+ * accounts list (see `meta.awaits`).
  *
  * @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<{
+export declare function useUnlinkAccount<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UnlinkAccountOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
     status: boolean;
 }, BetterFetchError, UnlinkAccountParams<TAuthClient>, unknown>;

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

@@ -1,29 +1,39 @@
-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
-			}
-		})
-	});
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+/**
+ * Mutation options factory for unlinking a social provider from the current user.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function unlinkAccountOptions(authClient) {
+    const mutationKey = authMutationKeys.unlinkAccount;
+    const mutationFn = (params) => authClient.unlinkAccount({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-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);
-		}
-	});
+/**
+ * Create a mutation for unlinking a social provider from the current user.
+ *
+ * On success, `MutationInvalidator` awaits invalidation of the linked
+ * accounts list (see `meta.awaits`).
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useUnlinkAccount(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...unlinkAccountOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [authQueryKeys.listAccounts(userId)]
+        }
+    }, queryClient);
 }
-//#endregion
-export { i as unlinkAccountOptions, a as useUnlinkAccount };

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

@@ -1,25 +1,25 @@
-import { BetterFetchError } from 'better-auth/react';
-import { AuthClient } from '../../lib/auth-client';
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { 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">;
+export type UpdateUserOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof updateUserOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * 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<{
+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`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the updated user fields are reflected (see `meta.awaits`).
  *
  * @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<{
+export declare function useUpdateUser<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UpdateUserOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
     status: boolean;
 }, BetterFetchError, UpdateUserParams<TAuthClient>, unknown>;

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

@@ -1,35 +1,36 @@
-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
-			}
-		})
-	});
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+/**
+ * Mutation options factory for updating the authenticated user's profile.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function updateUserOptions(authClient) {
+    const mutationKey = authMutationKeys.updateUser;
+    const mutationFn = (params) => authClient.updateUser({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-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);
-		}
-	});
+/**
+ * Create a mutation for updating the authenticated user's profile.
+ *
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the updated user fields are reflected (see `meta.awaits`).
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useUpdateUser(authClient, options, queryClient) {
+    return useMutation({
+        ...updateUserOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [authQueryKeys.session]
+        }
+    }, queryClient);
 }
-//#endregion
-export { o as updateUserOptions, s as useUpdateUser };

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

@@ -1,5 +1,5 @@
-import { BetterFetchError } from 'better-auth/react';
-import { UsernameAuthClient } from '../../lib/auth-client';
+import type { BetterFetchError } from "better-auth/react";
+import type { 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">;
 /**
@@ -10,7 +10,7 @@ export type IsUsernameAvailableOptions<TAuthClient extends UsernameAuthClient> =
  *
  * @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<{
+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">;
 /**
@@ -22,6 +22,6 @@ export declare function isUsernameAvailableOptions<TAuthClient extends UsernameA
  * @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<{
+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

@@ -1,24 +1,36 @@
-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
-			}
-		})
-	});
+import { usernameMutationKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+/**
+ * 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 function isUsernameAvailableOptions(authClient) {
+    const mutationKey = usernameMutationKeys.isUsernameAvailable;
+    const mutationFn = (params) => authClient.isUsernameAvailable({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-function i(e, t) {
-	return n({
-		...r(e),
-		...t
-	});
+/**
+ * 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 function useIsUsernameAvailable(authClient, options) {
+    return useMutation({
+        ...isUsernameAvailableOptions(authClient),
+        ...options
+    });
 }
-//#endregion
-export { r as isUsernameAvailableOptions, i as useIsUsernameAvailable };

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

@@ -1,13 +1,14 @@
-import { BetterFetchError } from 'better-auth/react';
-import { UsernameAuthClient } from '../../lib/auth-client';
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { 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">;
+export type SignInUsernameOptions<TAuthClient extends UsernameAuthClient> = Omit<ReturnType<typeof signInUsernameOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * 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<{
+export declare function signInUsernameOptions<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<Omit<{
     redirect: boolean;
     token: string;
     url: string | undefined;
@@ -24,7 +25,7 @@ export declare function signInUsernameOptions<TAuthClient extends UsernameAuthCl
         displayUsername: string;
     };
 }, "user"> & {
-    user: import('better-auth').StripEmptyObjects<{
+    user: import("better-auth").StripEmptyObjects<{
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -40,14 +41,13 @@ export declare function signInUsernameOptions<TAuthClient extends UsernameAuthCl
 /**
  * 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`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the new session is refetched (see `meta.awaits`).
  *
  * @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<{
+export declare function useSignInUsername<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient, options?: SignInUsernameOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<Omit<{
     redirect: boolean;
     token: string;
     url: string | undefined;
@@ -64,7 +64,7 @@ export declare function useSignInUsername<TAuthClient extends UsernameAuthClient
         displayUsername: string;
     };
 }, "user"> & {
-    user: import('better-auth').StripEmptyObjects<{
+    user: import("better-auth").StripEmptyObjects<{
         id: string;
         createdAt: Date;
         updatedAt: Date;

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

@@ -1,29 +1,37 @@
-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
-			}
-		})
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { usernameMutationKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+/**
+ * Mutation options factory for username/password sign-in.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function signInUsernameOptions(authClient) {
+    const mutationKey = usernameMutationKeys.signIn;
+    const mutationFn = (params) => authClient.signIn.username({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-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);
-		}
-	});
+/**
+ * Create a mutation for username/password sign-in.
+ *
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the new session is refetched (see `meta.awaits`).
+ *
+ * @param authClient - The Better Auth client with the username plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useSignInUsername(authClient, options, queryClient) {
+    return useMutation({
+        ...signInUsernameOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [authQueryKeys.session]
+        }
+    }, queryClient);
 }
-//#endregion
-export { a as signInUsernameOptions, o as useSignInUsername };

package/dist/plugins/captcha-plugin.d.ts

@@ -1,4 +1,4 @@
-import { ComponentType } from 'react';
+import { type ComponentType } from "react";
 /** Props passed to the consumer's `render` component. */
 export type CaptchaRenderProps = {
     /** Call once the user solves the captcha. */
@@ -19,10 +19,10 @@ export type CaptchaPluginOptions = {
  * Provider-agnostic captcha plugin. Forwards the resolved token via the
  * `x-captcha-response` header on Better Auth requests.
  */
-export declare const captchaPlugin: ((args_0: CaptchaPluginOptions) => Omit<{
+export declare const captchaPlugin: ((args_0: CaptchaPluginOptions) => {
     render: ComponentType<CaptchaRenderProps>;
     captchaComponent: import("react/jsx-runtime").JSX.Element;
-}, "id"> & {
+} & {
     id: "captcha";
 }) & {
     id: "captcha";