@better-auth-ui/react 1.6.3 → 1.6.5

package/dist/mutations/auth-mutation-options.d.ts

@@ -1,25 +1,42 @@
-import { MutationKey } from '@tanstack/react-query';
-import { BetterFetchError, BetterFetchOption } from 'better-auth/client';
-export type AuthMutationFn<TData = unknown, TVariables = unknown> = (params: TVariables & {
-    fetchOptions?: BetterFetchOption;
-}) => Promise<{
-    data: TData;
-}>;
-type AuthMutationFnData<TFn> = TFn extends AuthMutationFn<infer TData> ? TData : never;
-type AuthMutationFnVariables<TFn extends (...args: any) => any> = undefined extends Parameters<TFn>[0] ? // biome-ignore lint/suspicious/noConfusingVoidType: void lets `mutate()` be called with no arg
-void | NonNullable<Parameters<TFn>[0]> : Parameters<TFn>[0];
+import { MutationKey, UseMutationOptions } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/client';
 /**
- * Build `mutationOptions` for a Better Auth endpoint.
+ * Write-style Better Auth client method. Variables are a single object that
+ * may carry top-level params plus `fetchOptions` (e.g. `signIn.email` takes
+ * `{ email, password, rememberMe?, fetchOptions? }`).
  *
- * Wires `throw: true` into `fetchOptions` so the mutation rejects with a
- * `BetterFetchError` on failure instead of resolving with `{ error }`.
+ * Read-style endpoints use `AuthQueryFn` / `useAuthQuery` instead.
+ */
+export type AuthMutationFn = (variables: any) => Promise<unknown>;
+/**
+ * Resolved data type returned by an {@link AuthMutationFn}.
+ */
+export type AuthMutationFnData<TFn extends AuthMutationFn> = Awaited<ReturnType<TFn>>;
+/**
+ * Variables type accepted by `mutate` / `mutateAsync` for a given
+ * {@link AuthMutationFn}.
+ *
+ * If the method's params are entirely optional (e.g. `authClient.signOut`),
+ * this resolves to `Variables | void` so `mutate()` is callable without
+ * arguments. Otherwise it resolves to the exact required shape so the type
+ * checker rejects `mutate()` when the underlying call needs params.
+ */
+export type AuthMutationFnVariables<TFn extends AuthMutationFn> = Parameters<TFn>[0] extends infer P ? undefined extends P ? // biome-ignore lint/suspicious/noConfusingVoidType: void allows no-arg mutate
+NonNullable<P> | void : P : never;
+/**
+ * Return type of {@link authMutationOptions}, matching the shape produced by
+ * TanStack Query's own `mutationOptions` helper.
+ */
+export type AuthMutationOptions<TFn extends AuthMutationFn, TMutationKey extends MutationKey = MutationKey> = Omit<UseMutationOptions<AuthMutationFnData<TFn>, BetterFetchError, AuthMutationFnVariables<TFn>>, "mutationKey"> & {
+    mutationKey: TMutationKey;
+};
+/**
+ * Build `mutationOptions` for a write-style Better Auth endpoint.
  *
- * TData is inferred from the endpoint's non-throw response shape. For
- * required-body endpoints where inference falls back to `never`, pass
- * `TData` explicitly (e.g. `authMutationOptions<_, _, { available: boolean }>`).
+ * Injects `throw: true` into `fetchOptions` so the promise rejects with a
+ * `BetterFetchError` on failure instead of resolving to `{ data, error }`.
  *
- * @param authFn - Better Auth client method (e.g. `authClient.signIn.email`).
- * @param mutationKey - Scope for the mutation cache key.
+ * @param authFn - Better Auth client method (e.g. `authClient.emailOtp.sendVerificationOtp`).
+ * @param mutationKey - Stable key for the mutation (used by `useIsMutating`, `MutationCache`, …).
  */
-export declare function authMutationOptions<TFn extends (...args: any) => any, const TMutationKey extends MutationKey, TData = AuthMutationFnData<TFn>>(authFn: TFn, mutationKey: TMutationKey): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<TData, BetterFetchError, AuthMutationFnVariables<TFn>, unknown>, "mutationKey">;
-export {};
+export declare function authMutationOptions<TFn extends AuthMutationFn, const TMutationKey extends MutationKey>(authFn: TFn, mutationKey: TMutationKey): AuthMutationOptions<TFn, TMutationKey>;

package/dist/mutations/auth-mutation-options.js

@@ -4,11 +4,11 @@ function t(t, n) {
 	return e({
 		mutationKey: n,
 		mutationFn: (e) => {
-			let n = e;
+			let n = e ?? {};
 			return t({
 				...n,
 				fetchOptions: {
-					...n?.fetchOptions,
+					...n.fetchOptions,
 					throw: !0
 				}
 			});

package/dist/mutations/magic-link/sign-in-magic-link-mutation.d.ts

@@ -0,0 +1,24 @@
+import { BetterFetchError } from 'better-auth/react';
+import { MagicLinkAuthClient } from '../../lib/auth-client';
+export type SignInMagicLinkParams<TAuthClient extends MagicLinkAuthClient> = Parameters<TAuthClient["signIn"]["magicLink"]>[0];
+export type SignInMagicLinkOptions<TAuthClient extends MagicLinkAuthClient> = Omit<ReturnType<typeof signInMagicLinkOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for magic-link sign-in.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function signInMagicLinkOptions<TAuthClient extends MagicLinkAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, SignInMagicLinkParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for requesting a magic-link sign-in email.
+ *
+ * Wraps `authClient.signIn.magicLink` and forwards React Query mutation
+ * options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the magic-link plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useSignInMagicLink<TAuthClient extends MagicLinkAuthClient>(authClient: TAuthClient, options?: SignInMagicLinkOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, SignInMagicLinkParams<TAuthClient>, unknown>;

package/dist/mutations/magic-link/sign-in-magic-link-mutation.js

@@ -0,0 +1,24 @@
+import { mutationOptions as e, useMutation as t } from "@tanstack/react-query";
+import { magicLinkMutationKeys as n } from "@better-auth-ui/core/plugins";
+//#region src/mutations/magic-link/sign-in-magic-link-mutation.ts
+function r(t) {
+	let r = n.signIn;
+	return e({
+		mutationKey: r,
+		mutationFn: (e) => t.signIn.magicLink({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, n) {
+	return t({
+		...r(e),
+		...n
+	});
+}
+//#endregion
+export { r as signInMagicLinkOptions, i as useSignInMagicLink };

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

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

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

@@ -0,0 +1,29 @@
+import { useListDeviceSessions as e } from "../../queries/multi-session/list-device-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/multi-session/revoke-multi-session-mutation.ts
+function i(e) {
+	let r = t.multiSession.revoke;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.multiSession.revoke({
+			...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 revokeMultiSessionOptions, a as useRevokeMultiSession };

package/dist/mutations/multi-session/set-active-session-mutation.d.ts

@@ -0,0 +1,62 @@
+import { BetterFetchError } from 'better-auth/react';
+import { MultiSessionAuthClient } from '../../lib/auth-client';
+export type SetActiveSessionParams<TAuthClient extends MultiSessionAuthClient> = Parameters<TAuthClient["multiSession"]["setActive"]>[0];
+export type SetActiveSessionOptions<TAuthClient extends MultiSessionAuthClient> = Omit<ReturnType<typeof setActiveSessionOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for switching the active device session.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ */
+export declare function setActiveSessionOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+    } & Record<string, any>;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & Record<string, any>;
+}, BetterFetchError, SetActiveSessionParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for switching the active device session.
+ *
+ * Wraps `authClient.multiSession.setActive`, optimistically swaps the cached
+ * session to the matching device session, refetches both the session and
+ * device-session queries, and forwards React Query mutation options such as
+ * `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useSetActiveSession<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: SetActiveSessionOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+    } & Record<string, any>;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & Record<string, any>;
+}, BetterFetchError, SetActiveSessionParams<TAuthClient>, unknown>;

package/dist/mutations/multi-session/set-active-session-mutation.js

@@ -0,0 +1,31 @@
+import { sessionOptions as e, useSession as t } from "../../queries/auth/session-query.js";
+import { useListDeviceSessions as n } from "../../queries/multi-session/list-device-sessions-query.js";
+import { authMutationKeys as r } from "@better-auth-ui/core";
+import { mutationOptions as i, useMutation as a, useQueryClient as o } from "@tanstack/react-query";
+//#region src/mutations/multi-session/set-active-session-mutation.ts
+function s(e) {
+	let t = r.multiSession.setActive;
+	return i({
+		mutationKey: t,
+		mutationFn: (t) => e.multiSession.setActive({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function c(r, i) {
+	let c = o(), { refetch: l } = t(r, { refetchOnMount: !1 }), { data: u, refetch: d } = n(r, { refetchOnMount: !1 });
+	return a({
+		...s(r),
+		...i,
+		onSuccess: async (t, n, ...a) => {
+			let o = n?.sessionToken, s = u?.find(({ session: { token: e } }) => e === o);
+			s && c.setQueryData(e(r).queryKey, s), await l(), await d(), await i?.onSuccess?.(t, n, ...a);
+		}
+	});
+}
+//#endregion
+export { s as setActiveSessionOptions, c as useSetActiveSession };

package/dist/mutations/passkey/add-passkey-mutation.d.ts

@@ -0,0 +1,71 @@
+import { BetterFetchError } from 'better-auth/react';
+import { PasskeyAuthClient } from '../../lib/auth-client';
+export type AddPasskeyParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["passkey"]["addPasskey"]>[0];
+export type AddPasskeyOptions<TAuthClient extends PasskeyAuthClient> = Omit<ReturnType<typeof addPasskeyOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for registering a new passkey.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ */
+export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    data: import('@better-auth/passkey').Passkey;
+    error: null;
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: import('@better-auth/passkey').Passkey;
+    error: null;
+} | {
+    data: null;
+    error: {
+        code: string;
+        message: string;
+        status: number;
+        statusText: string;
+    };
+}, BetterFetchError, void | AddPasskeyParams<TAuthClient> | undefined, unknown>, "mutationKey">;
+/**
+ * Create a mutation for registering a new passkey.
+ *
+ * Wraps `authClient.passkey.addPasskey`, refetches the user's passkey list
+ * on success, and forwards React Query mutation options such as
+ * `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useAddPasskey<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: AddPasskeyOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    data: import('@better-auth/passkey').Passkey;
+    error: null;
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: import('@better-auth/passkey').Passkey;
+    error: null;
+} | {
+    data: null;
+    error: {
+        code: string;
+        message: string;
+        status: number;
+        statusText: string;
+    };
+}, BetterFetchError, void | AddPasskeyParams<TAuthClient> | undefined, unknown>;

package/dist/mutations/passkey/add-passkey-mutation.js

@@ -0,0 +1,29 @@
+import { useListPasskeys as e } from "../../queries/passkey/list-passkeys-query.js";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+import { passkeyMutationKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/passkey/add-passkey-mutation.ts
+function i(e) {
+	let n = r.addPasskey;
+	return t({
+		mutationKey: n,
+		mutationFn: (t) => e.passkey.addPasskey({
+			...t ?? {},
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function a(t, r) {
+	let { refetch: a } = e(t, { refetchOnMount: !1 });
+	return n({
+		...i(t),
+		...r,
+		onSuccess: async (...e) => {
+			await a(), await r?.onSuccess?.(...e);
+		}
+	});
+}
+//#endregion
+export { i as addPasskeyOptions, a as useAddPasskey };

package/dist/mutations/passkey/delete-passkey-mutation.d.ts

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

package/dist/mutations/passkey/delete-passkey-mutation.js

@@ -0,0 +1,29 @@
+import { useListPasskeys as e } from "../../queries/passkey/list-passkeys-query.js";
+import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
+import { passkeyMutationKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/passkey/delete-passkey-mutation.ts
+function i(e) {
+	let n = r.deletePasskey;
+	return t({
+		mutationKey: n,
+		mutationFn: (t) => e.passkey.deletePasskey({
+			...t,
+			fetchOptions: {
+				...t?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function a(t, r) {
+	let { refetch: a } = e(t, { refetchOnMount: !1 });
+	return n({
+		...i(t),
+		...r,
+		onSuccess: async (...e) => {
+			await a(), await r?.onSuccess?.(...e);
+		}
+	});
+}
+//#endregion
+export { i as deletePasskeyOptions, a as useDeletePasskey };

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

@@ -0,0 +1,105 @@
+import { BetterFetchError } from 'better-auth/react';
+import { PasskeyAuthClient } from '../../lib/auth-client';
+export type SignInPasskeyParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["signIn"]["passkey"]>[0];
+export type SignInPasskeyOptions<TAuthClient extends PasskeyAuthClient> = Omit<ReturnType<typeof signInPasskeyOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for passkey sign-in.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ */
+export declare function signInPasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    data: {
+        session: import('better-auth').Session;
+        user: import('better-auth').User;
+    };
+    error: null;
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: {
+        session: import('better-auth').Session;
+        user: import('better-auth').User;
+    };
+    error: null;
+} | {
+    data: null;
+    error: {
+        code: string;
+        message: string;
+        status: number;
+        statusText: string;
+    };
+}, BetterFetchError, void | SignInPasskeyParams<TAuthClient> | undefined, unknown>, "mutationKey">;
+/**
+ * Create a mutation for passkey sign-in.
+ *
+ * Wraps `authClient.signIn.passkey`, 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 passkey plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useSignInPasskey<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: SignInPasskeyOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    data: {
+        session: import('better-auth').Session;
+        user: import('better-auth').User;
+    };
+    error: null;
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: {
+        session: import('better-auth').Session;
+        user: import('better-auth').User;
+    };
+    error: null;
+} | {
+    data: null;
+    error: {
+        code: string;
+        message: string;
+        status: number;
+        statusText: string;
+    };
+}, BetterFetchError, void | SignInPasskeyParams<TAuthClient> | undefined, unknown>;

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

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

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

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type ChangeEmailParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["changeEmail"]>[0];
+export type ChangeEmailOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof changeEmailOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for changing the current user's email address.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function changeEmailOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, ChangeEmailParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for changing the current user's email address.
+ *
+ * Wraps `authClient.changeEmail`, refetches the session on success to
+ * surface the new email, 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 useChangeEmail<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: ChangeEmailOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, ChangeEmailParams<TAuthClient>, unknown>;

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

@@ -0,0 +1,29 @@
+import { useSession as e } from "../../queries/auth/session-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/change-email-mutation.ts
+function i(e) {
+	let r = t.changeEmail;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.changeEmail({
+			...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 changeEmailOptions, a as useChangeEmail };