@better-auth-ui/react 1.6.2 → 1.6.4

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

@@ -0,0 +1,19 @@
+import { mutationOptions as e } from "@tanstack/react-query";
+//#region src/mutations/auth-mutation-options.ts
+function t(t, n) {
+	return e({
+		mutationKey: n,
+		mutationFn: (e) => {
+			let n = e ?? {};
+			return t({
+				...n,
+				fetchOptions: {
+					...n.fetchOptions,
+					throw: !0
+				}
+			});
+		}
+	});
+}
+//#endregion
+export { t as authMutationOptions };

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

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