@better-auth-ui/react 1.6.2 → 1.6.4

package/dist/lib/auth-plugin.d.ts

@@ -0,0 +1,59 @@
+import { AuthPluginBase, AuthView } from '@better-auth-ui/core';
+import { ComponentType, ReactNode } from 'react';
+export type { AuthPluginViewPaths } from '@better-auth-ui/core';
+/** Props for plugin-contributed auth buttons (e.g. passkey, magic link). */
+export type AuthButtonProps = {
+    className?: string;
+    children?: ReactNode;
+    /** Current auth view — lets buttons context-switch (e.g. show "back to sign-in"). */
+    view?: AuthView;
+};
+/** Props for plugin-contributed cards under `/settings/security`. */
+export type SecurityCardProps = {
+    className?: string;
+    children?: ReactNode;
+};
+/** Props for plugin-contributed cards under `/settings/account`. */
+export type AccountCardProps = {
+    className?: string;
+    children?: ReactNode;
+};
+/** Props for plugin-contributed items in the `UserButton` dropdown. */
+export type UserMenuItemProps = {
+    className?: string;
+};
+/** Framework-agnostic slot component shapes. UI packages narrow these via `TComponents`. */
+export type AuthPluginComponents = {
+    /** Rendered below the submit button in auth forms. */
+    authButtons?: ComponentType<AuthButtonProps>[];
+    /** Rendered as cards inside security settings. */
+    securityCards?: ComponentType<SecurityCardProps>[];
+    /** Rendered as cards inside account settings. */
+    accountCards?: ComponentType<AccountCardProps>[];
+    /** Rendered as items inside the `UserButton` dropdown. */
+    userMenuItems?: ComponentType<UserMenuItemProps>[];
+};
+/** Plugin view overrides keyed by `AuthPluginViewPaths`. Always replaces the built-in view. */
+export type AuthPluginViews<TAuthViewProps, TSettingsViewProps> = {
+    auth?: Record<string, ComponentType<TAuthViewProps>>;
+    settings?: Record<string, ComponentType<TSettingsViewProps>>;
+};
+/** Conditional view replacements — only used when the built-in flow isn't viable. */
+export type AuthPluginFallbackViews<TAuthViewProps> = {
+    auth?: {
+        /** Rendered at `/auth/sign-in` when `emailAndPassword.enabled === false`. */
+        signIn?: ComponentType<TAuthViewProps>;
+    };
+};
+/**
+ * UI-aware plugin definition. UI packages bind the generics in their own
+ * `AuthPlugin` re-export so plugin authors don't have to.
+ *
+ * @typeParam TComponents - Slot component shapes (e.g. heroui variant unions).
+ * @typeParam TAuthViewProps - Props the `<Auth>` router spreads onto plugin auth views.
+ * @typeParam TSettingsViewProps - Props the `<Settings>` router spreads onto plugin settings views.
+ */
+export type AuthPlugin<TComponents = AuthPluginComponents, TAuthViewProps = any, TSettingsViewProps = any> = AuthPluginBase & TComponents & {
+    views?: AuthPluginViews<TAuthViewProps, TSettingsViewProps>;
+    fallbackViews?: AuthPluginFallbackViews<TAuthViewProps>;
+};

package/dist/lib/auth-server.d.ts

@@ -0,0 +1,16 @@
+import { passkey } from '@better-auth/passkey';
+import { Auth } from 'better-auth';
+import { magicLink, multiSession, username } from 'better-auth/plugins';
+export type AuthServer = Pick<Auth, "api">;
+export type MagicLinkAuthServer = Pick<Auth<{
+    plugins: [ReturnType<typeof magicLink>];
+}>, "api">;
+export type MultiSessionAuthServer = Pick<Auth<{
+    plugins: [ReturnType<typeof multiSession>];
+}>, "api">;
+export type PasskeyAuthServer = Pick<Auth<{
+    plugins: [ReturnType<typeof passkey>];
+}>, "api">;
+export type UsernameAuthServer = Pick<Auth<{
+    plugins: [ReturnType<typeof username>];
+}>, "api">;

package/dist/mutations/auth/request-password-reset-mutation.d.ts

@@ -0,0 +1,26 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type RequestPasswordResetParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["requestPasswordReset"]>[0];
+export type RequestPasswordResetOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof requestPasswordResetOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for requesting a password reset email.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function requestPasswordResetOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+    message: string;
+}, BetterFetchError, RequestPasswordResetParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for requesting a password reset email.
+ *
+ * Wraps `authClient.requestPasswordReset` 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 useRequestPasswordReset<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: RequestPasswordResetOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+    message: string;
+}, BetterFetchError, RequestPasswordResetParams<TAuthClient>, unknown>;

package/dist/mutations/auth/request-password-reset-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/auth/request-password-reset-mutation.ts
+function r(n) {
+	let r = e.requestPasswordReset;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.requestPasswordReset({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as requestPasswordResetOptions, i as useRequestPasswordReset };

package/dist/mutations/auth/reset-password-mutation.d.ts

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type ResetPasswordParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["resetPassword"]>[0];
+export type ResetPasswordOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof resetPasswordOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for completing a password reset.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function resetPasswordOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, ResetPasswordParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for completing a password reset.
+ *
+ * Wraps `authClient.resetPassword` (using the token from the reset 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 useResetPassword<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: ResetPasswordOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, ResetPasswordParams<TAuthClient>, unknown>;

package/dist/mutations/auth/reset-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/auth/reset-password-mutation.ts
+function r(n) {
+	let r = e.resetPassword;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.resetPassword({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as resetPasswordOptions, i as useResetPassword };

package/dist/mutations/auth/send-verification-email-mutation.d.ts

@@ -0,0 +1,24 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type SendVerificationEmailParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["sendVerificationEmail"]>[0];
+export type SendVerificationEmailOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof sendVerificationEmailOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for sending a verification email.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function sendVerificationEmailOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, SendVerificationEmailParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for sending an email-verification link.
+ *
+ * Wraps `authClient.sendVerificationEmail` 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 useSendVerificationEmail<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SendVerificationEmailOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, SendVerificationEmailParams<TAuthClient>, unknown>;

package/dist/mutations/auth/send-verification-email-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/auth/send-verification-email-mutation.ts
+function r(n) {
+	let r = e.sendVerificationEmail;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.sendVerificationEmail({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as sendVerificationEmailOptions, i as useSendVerificationEmail };

package/dist/mutations/auth/sign-in-email-mutation.d.ts

@@ -0,0 +1,71 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type SignInEmailParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signIn"]["email"]>[0];
+export type SignInEmailOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof signInEmailOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for email/password sign-in.
+ *
+ * The returned `mutationKey` (`authMutationKeys.signIn.email`) is stable and
+ * can be passed to `useIsMutating` or matched inside a global
+ * `MutationCache` observer for toast handling.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function signInEmailOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<Omit<{
+    redirect: boolean;
+    token: string;
+    url?: string | undefined;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}, BetterFetchError, SignInEmailParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for email/password sign-in.
+ *
+ * Wraps `authClient.signIn.email`, 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.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useSignInEmail<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignInEmailOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<Omit<{
+    redirect: boolean;
+    token: string;
+    url?: string | undefined;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}, BetterFetchError, SignInEmailParams<TAuthClient>, unknown>;

package/dist/mutations/auth/sign-in-email-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/auth/sign-in-email-mutation.ts
+function a(e) {
+	let r = t.signIn.email;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.signIn.email({
+			...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 signInEmailOptions, o as useSignInEmail };

package/dist/mutations/auth/sign-in-social-mutation.d.ts

@@ -0,0 +1,77 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type SignInSocialParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signIn"]["social"]>[0];
+export type SignInSocialOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof signInSocialOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for social sign-in.
+ *
+ * The returned `mutationKey` (`["auth", "signIn", "social"]`) is stable and
+ * can be passed to `useIsMutating` or matched inside a global
+ * `MutationCache` observer for toast handling.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function signInSocialOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    redirect: boolean;
+    url: string;
+} | (Omit<{
+    redirect: boolean;
+    token: string;
+    url: undefined;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}), BetterFetchError, SignInSocialParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for social sign-in.
+ *
+ * Wraps `authClient.signIn.social` 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 useSignInSocial<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignInSocialOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    redirect: boolean;
+    url: string;
+} | (Omit<{
+    redirect: boolean;
+    token: string;
+    url: undefined;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}), BetterFetchError, SignInSocialParams<TAuthClient>, unknown>;

package/dist/mutations/auth/sign-in-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/auth/sign-in-social-mutation.ts
+function r(n) {
+	let r = e.signIn.social;
+	return t({
+		mutationKey: r,
+		mutationFn: (e) => n.signIn.social({
+			...e,
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function i(e, t) {
+	return n({
+		...r(e),
+		...t
+	});
+}
+//#endregion
+export { r as signInSocialOptions, i as useSignInSocial };

package/dist/mutations/auth/sign-out-mutation.d.ts

@@ -0,0 +1,25 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type SignOutParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signOut"]>[0];
+export type SignOutOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof signOutOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for signing out.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function signOutOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+    success: boolean;
+}, BetterFetchError, void | SignOutParams<TAuthClient> | undefined, unknown>, "mutationKey">;
+/**
+ * Create a mutation for signing the current user out.
+ *
+ * Wraps `authClient.signOut`, removes all cached auth queries 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 useSignOut<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignOutOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+    success: boolean;
+}, BetterFetchError, void | SignOutParams<TAuthClient> | undefined, unknown>;

package/dist/mutations/auth/sign-out-mutation.js

@@ -0,0 +1,28 @@
+import { authMutationKeys as e, authQueryKeys as t } from "@better-auth-ui/core";
+import { mutationOptions as n, useMutation as r, useQueryClient as i } from "@tanstack/react-query";
+//#region src/mutations/auth/sign-out-mutation.ts
+function a(t) {
+	let r = e.signOut;
+	return n({
+		mutationKey: r,
+		mutationFn: (e) => t.signOut({
+			...e ?? {},
+			fetchOptions: {
+				...e?.fetchOptions,
+				throw: !0
+			}
+		})
+	});
+}
+function o(e, n) {
+	let o = i();
+	return r({
+		...a(e),
+		...n,
+		onSuccess: async (...e) => {
+			o.removeQueries({ queryKey: t.all }), await n?.onSuccess?.(...e);
+		}
+	});
+}
+//#endregion
+export { a as signOutOptions, o as useSignOut };

package/dist/mutations/auth/sign-up-email-mutation.d.ts

@@ -0,0 +1,105 @@
+import { BetterFetchError } from 'better-auth/react';
+import { AuthClient } from '../../lib/auth-client';
+export type SignUpEmailParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signUp"]["email"]>[0];
+export type SignUpEmailOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof signUpEmailOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for email/password sign-up.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function signUpEmailOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<(Omit<{
+    token: null;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}) | (Omit<{
+    token: string;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}), BetterFetchError, SignUpEmailParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for email/password sign-up.
+ *
+ * Wraps `authClient.signUp.email`, 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.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useSignUpEmail<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignUpEmailOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<(Omit<{
+    token: null;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}) | (Omit<{
+    token: string;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+    };
+}, "user"> & {
+    user: import('better-auth').StripEmptyObjects<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    }>;
+}), BetterFetchError, SignUpEmailParams<TAuthClient>, unknown>;

package/dist/mutations/auth/sign-up-email-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/auth/sign-up-email-mutation.ts
+function a(e) {
+	let r = t.signUp.email;
+	return n({
+		mutationKey: r,
+		mutationFn: (t) => e.signUp.email({
+			...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 signUpEmailOptions, o as useSignUpEmail };

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

@@ -0,0 +1,42 @@
+import { MutationKey, UseMutationOptions } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/client';
+/**
+ * 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? }`).
+ *
+ * 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.
+ *
+ * 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.emailOtp.sendVerificationOtp`).
+ * @param mutationKey - Stable key for the mutation (used by `useIsMutating`, `MutationCache`, …).
+ */
+export declare function authMutationOptions<TFn extends AuthMutationFn, const TMutationKey extends MutationKey>(authFn: TFn, mutationKey: TMutationKey): AuthMutationOptions<TFn, TMutationKey>;