@better-auth-ui/react 1.6.2 → 1.6.4

package/src/server/queries/passkey/list-passkeys-query.ts

@@ -0,0 +1,100 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { PasskeyAuthServer } from "../../../lib/auth-server"
+
+export type ListPasskeysData<TAuth extends PasskeyAuthServer> = Awaited<
+  ReturnType<TAuth["api"]["listPasskeys"]>
+>
+
+export type ListPasskeysParams<TAuth extends PasskeyAuthServer> = Parameters<
+  TAuth["api"]["listPasskeys"]
+>[0]
+
+export type ListPasskey<TAuth extends PasskeyAuthServer = PasskeyAuthServer> =
+  NonNullable<ListPasskeysData<TAuth>>[number]
+
+/**
+ * Query options factory for the current user's passkeys.
+ *
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listPasskeysOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export function listPasskeysOptions<TAuth extends PasskeyAuthServer>(
+  auth: TAuth,
+  userId: string,
+  params: ListPasskeysParams<TAuth>
+) {
+  type TData = ListPasskeysData<TAuth>
+  const queryKey = authQueryKeys.listPasskeys(userId, params?.query)
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.listPasskeys(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current user's passkeys from the query cache, calling
+ * `fetchListPasskeys` under the hood if no cached entry exists. Resolves
+ * with the passkey list, making it suitable for reading directly in a server
+ * component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export const ensureListPasskeys = <TAuth extends PasskeyAuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListPasskeysParams<TAuth>
+) => queryClient.ensureQueryData(listPasskeysOptions(auth, userId, params))
+
+/**
+ * Prefetch the current user's passkeys into the query cache. Behaves like
+ * `fetchListPasskeys`, but does not throw on error and does not return
+ * the data — use this when you only need the value to be available after
+ * hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export const prefetchListPasskeys = <TAuth extends PasskeyAuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListPasskeysParams<TAuth>
+) => queryClient.prefetchQuery(listPasskeysOptions(auth, userId, params))
+
+/**
+ * Fetch and cache the current user's passkeys, resolving with the data or
+ * throwing on error. If a cached entry exists and is neither invalidated
+ * nor older than `staleTime`, the cached value is returned without a
+ * network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export const fetchListPasskeys = <TAuth extends PasskeyAuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListPasskeysParams<TAuth>
+) => queryClient.fetchQuery(listPasskeysOptions(auth, userId, params))

package/src/server/queries/settings/account-info-query.ts

@@ -0,0 +1,101 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { AuthServer } from "../../../lib/auth-server"
+
+export type AccountInfoData<TAuth extends AuthServer = AuthServer> = Awaited<
+  ReturnType<TAuth["api"]["accountInfo"]>
+>
+
+export type AccountInfoParams<TAuth extends AuthServer> = Parameters<
+  TAuth["api"]["accountInfo"]
+>[0]
+
+export type AccountInfo<TAuth extends AuthServer = AuthServer> = NonNullable<
+  AccountInfoData<TAuth>
+>
+
+/**
+ * Query options factory for provider-specific account info.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `accountInfoOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export function accountInfoOptions<TAuth extends AuthServer>(
+  auth: TAuth,
+  userId: string,
+  params: AccountInfoParams<TAuth>
+) {
+  type TData = AccountInfoData<TAuth>
+  const queryKey = authQueryKeys.accountInfo(userId, params?.query)
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.accountInfo(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current user's provider-specific account info from the query
+ * cache, calling `fetchAccountInfo` under the hood if no cached entry
+ * exists. Resolves with the data, making it suitable for reading directly
+ * in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export const ensureAccountInfo = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: AccountInfoParams<TAuth>
+) => queryClient.ensureQueryData(accountInfoOptions(auth, userId, params))
+
+/**
+ * Prefetch the current user's provider-specific account info into the query
+ * cache. Behaves like `fetchAccountInfo`, but does not throw on error and
+ * does not return the data — use this when you only need the value to be
+ * available after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export const prefetchAccountInfo = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: AccountInfoParams<TAuth>
+) => queryClient.prefetchQuery(accountInfoOptions(auth, userId, params))
+
+/**
+ * Fetch and cache the current user's provider-specific account info,
+ * resolving with the data or throwing on error. If a cached entry exists
+ * and is neither invalidated nor older than `staleTime`, the cached value
+ * is returned without a network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export const fetchAccountInfo = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: AccountInfoParams<TAuth>
+) => queryClient.fetchQuery(accountInfoOptions(auth, userId, params))

package/src/server/queries/settings/list-accounts-query.ts

@@ -0,0 +1,101 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { AuthServer } from "../../../lib/auth-server"
+
+export type ListAccountsData<TAuth extends AuthServer = AuthServer> = Awaited<
+  ReturnType<TAuth["api"]["listUserAccounts"]>
+>
+
+export type ListAccountsParams<TAuth extends AuthServer> = Parameters<
+  TAuth["api"]["listUserAccounts"]
+>[0]
+
+export type ListAccount<TAuth extends AuthServer = AuthServer> = NonNullable<
+  ListAccountsData<TAuth>
+>[number]
+
+/**
+ * Query options factory for the current user's linked social accounts.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listAccountsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export function listAccountsOptions<TAuth extends AuthServer>(
+  auth: TAuth,
+  userId: string,
+  params: ListAccountsParams<TAuth>
+) {
+  type TData = ListAccountsData<TAuth>
+  const queryKey = authQueryKeys.listAccounts(userId, params?.query)
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.listUserAccounts(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current user's linked social accounts from the query cache,
+ * calling `fetchListAccounts` under the hood if no cached entry exists.
+ * Resolves with the account list, making it suitable for reading directly
+ * in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export const ensureListAccounts = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListAccountsParams<TAuth>
+) => queryClient.ensureQueryData(listAccountsOptions(auth, userId, params))
+
+/**
+ * Prefetch the current user's linked social accounts into the query cache.
+ * Behaves like `fetchListAccounts`, but does not throw on error and does
+ * not return the data — use this when you only need the value to be
+ * available after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export const prefetchListAccounts = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListAccountsParams<TAuth>
+) => queryClient.prefetchQuery(listAccountsOptions(auth, userId, params))
+
+/**
+ * Fetch and cache the current user's linked social accounts, resolving
+ * with the data or throwing on error. If a cached entry exists and is
+ * neither invalidated nor older than `staleTime`, the cached value is
+ * returned without a network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export const fetchListAccounts = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListAccountsParams<TAuth>
+) => queryClient.fetchQuery(listAccountsOptions(auth, userId, params))

package/src/server/queries/settings/list-sessions-query.ts

@@ -0,0 +1,101 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { AuthServer } from "../../../lib/auth-server"
+
+export type ListSessionsData<TAuth extends AuthServer = AuthServer> = Awaited<
+  ReturnType<TAuth["api"]["listSessions"]>
+>
+
+export type ListSessionsParams<TAuth extends AuthServer> = Parameters<
+  TAuth["api"]["listSessions"]
+>[0]
+
+export type ListSession<TAuth extends AuthServer = AuthServer> = NonNullable<
+  ListSessionsData<TAuth>
+>[number]
+
+/**
+ * Query options factory for the current user's active sessions.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listSessionsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listSessions`.
+ */
+export function listSessionsOptions<TAuth extends AuthServer>(
+  auth: TAuth,
+  userId: string,
+  params: ListSessionsParams<TAuth>
+) {
+  type TData = ListSessionsData<TAuth>
+  const queryKey = authQueryKeys.listSessions(userId, params?.query)
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.listSessions(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current user's active sessions from the query cache, calling
+ * `fetchListSessions` under the hood if no cached entry exists. Resolves
+ * with the session list, making it suitable for reading directly in a server
+ * component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listSessions`.
+ */
+export const ensureListSessions = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListSessionsParams<TAuth>
+) => queryClient.ensureQueryData(listSessionsOptions(auth, userId, params))
+
+/**
+ * Prefetch the current user's active sessions into the query cache. Behaves
+ * like `fetchListSessions`, but does not throw on error and does not return
+ * the data — use this when you only need the value to be available after
+ * hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listSessions`.
+ */
+export const prefetchListSessions = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListSessionsParams<TAuth>
+) => queryClient.prefetchQuery(listSessionsOptions(auth, userId, params))
+
+/**
+ * Fetch and cache the current user's active sessions, resolving with the
+ * data or throwing on error. If a cached entry exists and is neither
+ * invalidated nor older than `staleTime`, the cached value is returned
+ * without a network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listSessions`.
+ */
+export const fetchListSessions = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListSessionsParams<TAuth>
+) => queryClient.fetchQuery(listSessionsOptions(auth, userId, params))

package/src/server.ts

@@ -0,0 +1,7 @@
+export type * from "./lib/auth-server"
+export * from "./server/queries/auth/session-query"
+export * from "./server/queries/multi-session/list-device-sessions-query"
+export * from "./server/queries/passkey/list-passkeys-query"
+export * from "./server/queries/settings/account-info-query"
+export * from "./server/queries/settings/list-accounts-query"
+export * from "./server/queries/settings/list-sessions-query"

package/dist/core.d.ts

@@ -1 +0,0 @@
-export * from '@better-auth-ui/core';

package/dist/core.js

@@ -1 +0,0 @@
-export * from "@better-auth-ui/core";

package/dist/hooks/auth/use-auth-mutation.d.ts

@@ -1,18 +0,0 @@
-import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import { BetterFetchError } from 'better-auth/react';
-type AuthFn = (...args: any) => Promise<any>;
-type MutationParams<TFn extends AuthFn> = undefined extends Parameters<TFn>[0] ? // biome-ignore lint/suspicious/noConfusingVoidType: void is needed for mutations with optional params
-void | Omit<NonNullable<Parameters<TFn>[0]>, "fetchOptions"> : Omit<Parameters<TFn>[0], "fetchOptions">;
-type InferMutationData<TFn extends AuthFn> = TFn extends (...args: infer _A) => infer R ? Extract<Awaited<R>, {
-    error: null;
-}> extends {
-    data: infer D;
-} ? D : Awaited<R> : Awaited<ReturnType<TFn>>;
-export type UseAuthMutationOptions<TFn extends AuthFn> = Omit<UseMutationOptions<InferMutationData<TFn>, BetterFetchError, MutationParams<TFn>>, "mutationFn">;
-export type UseAuthMutationResult<TFn extends AuthFn> = UseMutationResult<InferMutationData<TFn>, BetterFetchError, MutationParams<TFn>>;
-type UseAuthMutationProps<TFn extends AuthFn> = {
-    authFn: TFn;
-    options?: UseAuthMutationOptions<TFn>;
-};
-export declare function useAuthMutation<TFn extends AuthFn>({ authFn, options }: UseAuthMutationProps<TFn>): UseAuthMutationResult<TFn>;
-export {};

package/dist/hooks/auth/use-auth-mutation.js

@@ -1,13 +0,0 @@
-import { useMutation as e } from "@tanstack/react-query";
-//#region src/hooks/auth/use-auth-mutation.ts
-function t({ authFn: t, options: n }) {
-	return e({
-		mutationFn: (e) => t({
-			...e,
-			fetchOptions: { throw: !0 }
-		}),
-		...n
-	});
-}
-//#endregion
-export { t as useAuthMutation };

package/dist/hooks/auth/use-auth-query.d.ts

@@ -1,24 +0,0 @@
-import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
-import { BetterFetchError, BetterFetchOption } from 'better-auth/react';
-type BetterFetchFn = (options: {
-    fetchOptions?: BetterFetchOption;
-}) => Promise<{
-    data: unknown;
-}>;
-type InferData<TFn> = TFn extends (options: {
-    fetchOptions?: BetterFetchOption;
-}) => Promise<{
-    data: infer TData;
-}> ? TData : never;
-type OmitFetchOptions<T> = {
-    [K in keyof T as K extends "fetchOptions" ? never : K]: T[K];
-};
-export type UseAuthQueryOptions<TFn extends BetterFetchFn> = Omit<UseQueryOptions<InferData<TFn>, BetterFetchError>, "queryFn">;
-export type UseAuthQueryResult<TFn extends BetterFetchFn> = UseQueryResult<InferData<TFn>, BetterFetchError>;
-type UseAuthQueryProps<TFn extends BetterFetchFn> = {
-    authFn: TFn;
-    params?: OmitFetchOptions<Parameters<TFn>[0]>;
-    options: UseAuthQueryOptions<TFn>;
-};
-export declare function useAuthQuery<TFn extends BetterFetchFn>({ authFn, params, options }: UseAuthQueryProps<TFn>): UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TFn>>, BetterFetchError>;
-export {};

package/dist/hooks/auth/use-auth-query.js

@@ -1,13 +0,0 @@
-import { useQuery as e } from "@tanstack/react-query";
-//#region src/hooks/auth/use-auth-query.ts
-function t({ authFn: t, params: n, options: r }) {
-	return e({
-		queryFn: async () => await t({
-			...n,
-			fetchOptions: { throw: !0 }
-		}),
-		...r
-	});
-}
-//#endregion
-export { t as useAuthQuery };

package/dist/hooks/auth/use-is-username-available.d.ts

@@ -1,19 +0,0 @@
-import { AuthClient } from '../../lib/auth-client';
-import { UseAuthMutationOptions } from './use-auth-mutation';
-/**
- * Hook that creates a mutation to check if a username is available.
- *
- * @returns The `useMutation` result where data contains `{ available: boolean }`.
- */
-export declare function useIsUsernameAvailable(options?: UseAuthMutationOptions<AuthClient["isUsernameAvailable"]>): import('./use-auth-mutation').UseAuthMutationResult<(<FetchOptions extends import('better-auth').ClientFetchOption<Partial<{
-    username: string;
-}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import('better-auth').Prettify<{
-    username: string;
-} & {
-    fetchOptions?: FetchOptions | undefined;
-}>, data_1?: FetchOptions | undefined) => Promise<import('better-auth/client').BetterFetchResponse<{
-    available: boolean;
-}, {
-    code?: string | undefined;
-    message?: string | undefined;
-}, FetchOptions["throw"] extends true ? true : false>>)>;

package/dist/hooks/auth/use-is-username-available.js

@@ -1,12 +0,0 @@
-import { useAuth as e } from "../../components/auth/auth-provider.js";
-import { useAuthMutation as t } from "./use-auth-mutation.js";
-//#region src/hooks/auth/use-is-username-available.ts
-function n(n) {
-	let { authClient: r } = e();
-	return t({
-		authFn: r.isUsernameAvailable,
-		options: n
-	});
-}
-//#endregion
-export { n as useIsUsernameAvailable };

package/dist/hooks/auth/use-request-password-reset.d.ts

@@ -1,25 +0,0 @@
-import { AuthClient } from '../../lib/auth-client';
-import { UseAuthMutationOptions } from './use-auth-mutation';
-/**
- * Hook that creates a mutation for the forgot-password flow.
- *
- * The mutation sends a password reset request for the submitted email,
- * and navigates to the sign-in view on success.
- *
- * @returns The `useMutation` result.
- */
-export declare function useRequestPasswordReset(options?: UseAuthMutationOptions<AuthClient["requestPasswordReset"]>): import('./use-auth-mutation').UseAuthMutationResult<(<FetchOptions extends import('better-auth').ClientFetchOption<Partial<{
-    email: string;
-    redirectTo?: string | undefined;
-}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import('better-auth').Prettify<{
-    email: string;
-    redirectTo?: string | undefined;
-} & {
-    fetchOptions?: FetchOptions | undefined;
-}>, data_1?: FetchOptions | undefined) => Promise<import('better-auth/client').BetterFetchResponse<{
-    status: boolean;
-    message: string;
-}, {
-    code?: string | undefined;
-    message?: string | undefined;
-}, FetchOptions["throw"] extends true ? true : false>>)>;

package/dist/hooks/auth/use-request-password-reset.js

@@ -1,12 +0,0 @@
-import { useAuth as e } from "../../components/auth/auth-provider.js";
-import { useAuthMutation as t } from "./use-auth-mutation.js";
-//#region src/hooks/auth/use-request-password-reset.ts
-function n(n) {
-	let { authClient: r } = e();
-	return t({
-		authFn: r.requestPasswordReset,
-		options: n
-	});
-}
-//#endregion
-export { n as useRequestPasswordReset };

package/dist/hooks/auth/use-reset-password.d.ts

@@ -1,39 +0,0 @@
-import { AuthClient } from '../../lib/auth-client';
-import { UseAuthMutationOptions } from './use-auth-mutation';
-/**
- * Hook that creates a mutation for the reset-password flow.
- *
- * The mutation resets the user's password using the provided token and new password.
- *
- * @returns The `useMutation` result.
- */
-export declare function useResetPassword(options?: UseAuthMutationOptions<AuthClient["resetPassword"]>): import('./use-auth-mutation').UseAuthMutationResult<(<FetchOptions extends import('better-auth').ClientFetchOption<Partial<{
-    newPassword: string;
-    token?: string | undefined;
-}> & Record<string, any>, Partial<{
-    token?: string | undefined;
-}> & Record<string, any>, Record<string, any> | undefined>>(data_0: import('better-auth').Prettify<{
-    newPassword: string;
-    token?: string | undefined;
-} & {
-    fetchOptions?: FetchOptions | undefined;
-}>, data_1?: FetchOptions | undefined) => Promise<import('better-auth/client').BetterFetchResponse<{
-    status: boolean;
-}, {
-    code?: string | undefined;
-    message?: string | undefined;
-}, FetchOptions["throw"] extends true ? true : false>>) & {
-    ":token": <FetchOptions extends import('better-auth').ClientFetchOption<never, Partial<{
-        callbackURL: string;
-    }> & Record<string, any>, {
-        token: string;
-    }>>(data_0: import('better-auth').Prettify<{
-        query: {
-            callbackURL: string;
-        };
-        fetchOptions?: FetchOptions | undefined;
-    }>, data_1?: FetchOptions | undefined) => Promise<import('better-auth/client').BetterFetchResponse<never, {
-        code?: string | undefined;
-        message?: string | undefined;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-}>;

package/dist/hooks/auth/use-reset-password.js

@@ -1,12 +0,0 @@
-import { useAuth as e } from "../../components/auth/auth-provider.js";
-import { useAuthMutation as t } from "./use-auth-mutation.js";
-//#region src/hooks/auth/use-reset-password.ts
-function n(n) {
-	let { authClient: r } = e();
-	return t({
-		authFn: r.resetPassword,
-		options: n
-	});
-}
-//#endregion
-export { n as useResetPassword };

package/dist/hooks/auth/use-send-verification-email.d.ts

@@ -1,23 +0,0 @@
-import { AuthClient } from '../../lib/auth-client';
-import { UseAuthMutationOptions } from './use-auth-mutation';
-/**
- * Hook that creates a mutation to send a verification email.
- *
- * The mutation sends a verification email to the specified email address.
- *
- * @returns The `useMutation` result.
- */
-export declare function useSendVerificationEmail(options?: UseAuthMutationOptions<AuthClient["sendVerificationEmail"]>): import('./use-auth-mutation').UseAuthMutationResult<(<FetchOptions extends import('better-auth').ClientFetchOption<Partial<{
-    email: string;
-    callbackURL?: string | undefined;
-}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import('better-auth').Prettify<{
-    email: string;
-    callbackURL?: string | undefined;
-} & {
-    fetchOptions?: FetchOptions | undefined;
-}>, data_1?: FetchOptions | undefined) => Promise<import('better-auth/client').BetterFetchResponse<{
-    status: boolean;
-}, {
-    code?: string | undefined;
-    message?: string | undefined;
-}, FetchOptions["throw"] extends true ? true : false>>)>;

package/dist/hooks/auth/use-send-verification-email.js

@@ -1,12 +0,0 @@
-import { useAuth as e } from "../../components/auth/auth-provider.js";
-import { useAuthMutation as t } from "./use-auth-mutation.js";
-//#region src/hooks/auth/use-send-verification-email.ts
-function n(n) {
-	let { authClient: r } = e();
-	return t({
-		authFn: r.sendVerificationEmail,
-		options: n
-	});
-}
-//#endregion
-export { n as useSendVerificationEmail };

package/dist/hooks/auth/use-session.d.ts

@@ -1,9 +0,0 @@
-import { AuthClient } from '../../lib/auth-client';
-import { UseAuthQueryOptions, UseAuthQueryResult } from './use-auth-query';
-/**
- * Retrieve the current authentication session.
- *
- * @param options - Options to merge into the React Query configuration for the session query.
- * @returns The React Query result for the session query: `data` contains session information, `isLoading`/`isFetching` indicate loading state, and `error` contains any fetch error.
- */
-export declare function useSession(options?: Partial<UseAuthQueryOptions<AuthClient["getSession"]>>): UseAuthQueryResult<AuthClient["getSession"]>;