@better-auth-ui/react 1.6.8 → 1.6.9

package/dist/server/queries/organization/list-members-query.js

@@ -0,0 +1,21 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { queryOptions } from "@tanstack/react-query";
+/**
+ * Query options factory for members of an organization.
+ *
+ * @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 `listOrganizationMembersOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listMembers`.
+ */
+export function listOrganizationMembersOptions(auth, userId, params) {
+    const queryKey = organizationQueryKeys.members.list(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: () => auth.api.listMembers(params)
+    });
+    return options;
+}
+export const ensureListOrganizationMembers = (queryClient, auth, userId, params) => queryClient.ensureQueryData(listOrganizationMembersOptions(auth, userId, params));
+export const prefetchListOrganizationMembers = (queryClient, auth, userId, params) => queryClient.prefetchQuery(listOrganizationMembersOptions(auth, userId, params));
+export const fetchListOrganizationMembers = (queryClient, auth, userId, params) => queryClient.fetchQuery(listOrganizationMembersOptions(auth, userId, params));

package/dist/server/queries/organization/list-organizations-query.d.ts

@@ -0,0 +1,27 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { OrganizationAuthServer } from "../../../lib/auth-server";
+export type ListOrganizationsData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Awaited<ReturnType<TAuth["api"]["listOrganizations"]>>;
+export type ListOrganization<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = NonNullable<ListOrganizationsData<TAuth>>[number];
+export type ListOrganizationsParams<TAuth extends OrganizationAuthServer> = Parameters<TAuth["api"]["listOrganizations"]>[0];
+/**
+ * Query options factory for organizations the current user belongs to.
+ *
+ * @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 `listOrganizationsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listOrganizations`.
+ */
+export declare function listOrganizationsOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: ListOrganizationsParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listOrganizations"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listOrganizations"]>>, readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listOrganizations"]>>, readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listOrganizations"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listOrganizations"]>>, APIError>;
+};
+export declare const ensureListOrganizations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listOrganizations"]>>>;
+export declare const prefetchListOrganizations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationsParams<TAuth>) => Promise<void>;
+export declare const fetchListOrganizations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listOrganizations"]>>>;

package/dist/server/queries/organization/list-organizations-query.js

@@ -0,0 +1,21 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { queryOptions } from "@tanstack/react-query";
+/**
+ * Query options factory for organizations the current user belongs to.
+ *
+ * @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 `listOrganizationsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listOrganizations`.
+ */
+export function listOrganizationsOptions(auth, userId, params) {
+    const queryKey = organizationQueryKeys.list(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: () => auth.api.listOrganizations(params)
+    });
+    return options;
+}
+export const ensureListOrganizations = (queryClient, auth, userId, params) => queryClient.ensureQueryData(listOrganizationsOptions(auth, userId, params));
+export const prefetchListOrganizations = (queryClient, auth, userId, params) => queryClient.prefetchQuery(listOrganizationsOptions(auth, userId, params));
+export const fetchListOrganizations = (queryClient, auth, userId, params) => queryClient.fetchQuery(listOrganizationsOptions(auth, userId, params));

package/dist/server/queries/organization/list-user-invitations-query.d.ts

@@ -0,0 +1,34 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { OrganizationAuthServer } from "../../../lib/auth-server";
+export type ListUserInvitationsData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Awaited<ReturnType<TAuth["api"]["listUserInvitations"]>>;
+export type ListUserInvitationsParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Parameters<TAuth["api"]["listUserInvitations"]>[0];
+/**
+ * Query options factory for invitations addressed to the current user.
+ *
+ * @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 `listUserInvitationsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listUserInvitations`.
+ */
+export declare function listUserInvitationsOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: ListUserInvitationsParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listUserInvitations"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listUserInvitations"]>>, readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+    email?: string | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listUserInvitations"]>>, readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+        email?: string | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+        email?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listUserInvitations"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+        email?: string | undefined;
+    } | null], Awaited<ReturnType<TAuth["api"]["listUserInvitations"]>>, APIError>;
+};
+export declare const ensureListUserInvitations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListUserInvitationsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listUserInvitations"]>>>;
+export declare const prefetchListUserInvitations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListUserInvitationsParams<TAuth>) => Promise<void>;
+export declare const fetchListUserInvitations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListUserInvitationsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listUserInvitations"]>>>;

package/dist/server/queries/organization/list-user-invitations-query.js

@@ -0,0 +1,21 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { queryOptions } from "@tanstack/react-query";
+/**
+ * Query options factory for invitations addressed to the current user.
+ *
+ * @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 `listUserInvitationsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listUserInvitations`.
+ */
+export function listUserInvitationsOptions(auth, userId, params) {
+    const queryKey = organizationQueryKeys.userInvitations.list(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: () => auth.api.listUserInvitations(params)
+    });
+    return options;
+}
+export const ensureListUserInvitations = (queryClient, auth, userId, params) => queryClient.ensureQueryData(listUserInvitationsOptions(auth, userId, params));
+export const prefetchListUserInvitations = (queryClient, auth, userId, params) => queryClient.prefetchQuery(listUserInvitationsOptions(auth, userId, params));
+export const fetchListUserInvitations = (queryClient, auth, userId, params) => queryClient.fetchQuery(listUserInvitationsOptions(auth, userId, params));

package/dist/server/queries/passkey/list-passkeys-query.d.ts

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { APIError } from 'better-auth';
-import { PasskeyAuthServer } from '../../../lib/auth-server';
+import { type DataTag, type QueryClient } 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];
@@ -12,15 +12,15 @@ export type ListPasskey<TAuth extends PasskeyAuthServer = PasskeyAuthServer> = N
  *   the key matches the client-side `listPasskeysOptions` for SSR hydration.
  * @param params - Parameters forwarded to `auth.api.listPasskeys`.
  */
-export declare function listPasskeysOptions<TAuth extends PasskeyAuthServer>(auth: TAuth, userId: string, params: ListPasskeysParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null], never> | undefined;
+export declare function listPasskeysOptions<TAuth extends PasskeyAuthServer>(auth: TAuth, userId: string, params: ListPasskeysParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null], never> | undefined;
 } & {
-    queryKey: readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null] & {
+    queryKey: readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null] & {
         [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>;
         [dataTagErrorSymbol]: APIError;
     };
 }) & {
-    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, APIError>;
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listPasskeys"]>>, APIError>;
 };
 /**
  * Get the current user's passkeys from the query cache, calling

package/dist/server/queries/passkey/list-passkeys-query.js

@@ -1,12 +1,54 @@
-import { authQueryKeys as e } from "@better-auth-ui/core";
-import { queryOptions as t } from "@tanstack/react-query";
-//#region src/server/queries/passkey/list-passkeys-query.ts
-function n(n, r, i) {
-	return t({
-		queryKey: e.listPasskeys(r, i?.query),
-		queryFn: () => n.api.listPasskeys(i)
-	});
+import { passkeyQueryKeys } from "@better-auth-ui/core/plugins";
+import { queryOptions } from "@tanstack/react-query";
+/**
+ * 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(auth, userId, params) {
+    const queryKey = passkeyQueryKeys.list(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: () => auth.api.listPasskeys(params)
+    });
+    return options;
 }
-var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
-//#endregion
-export { r as ensureListPasskeys, a as fetchListPasskeys, n as listPasskeysOptions, i as prefetchListPasskeys };
+/**
+ * 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 = (queryClient, auth, userId, params) => 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 = (queryClient, auth, userId, params) => 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 = (queryClient, auth, userId, params) => queryClient.fetchQuery(listPasskeysOptions(auth, userId, params));

package/dist/server/queries/settings/account-info-query.d.ts

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { APIError } from 'better-auth';
-import { AuthServer } from '../../../lib/auth-server';
+import { type DataTag, type QueryClient } 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>>;
@@ -12,10 +12,10 @@ export type AccountInfo<TAuth extends AuthServer = AuthServer> = NonNullable<Acc
  *   the key matches the client-side `accountInfoOptions` for SSR hydration.
  * @param params - Parameters forwarded to `auth.api.accountInfo`.
  */
-export declare function accountInfoOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: AccountInfoParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, APIError, Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, readonly ["auth", "user", string | undefined, "accountInfo", {
+export declare function accountInfoOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: AccountInfoParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, APIError, Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, readonly ["auth", "user", string | undefined, "accountInfo", {
     accountId?: string | undefined;
 } | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, readonly ["auth", "user", string | undefined, "accountInfo", {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["accountInfo"]>>, readonly ["auth", "user", string | undefined, "accountInfo", {
         accountId?: string | undefined;
     } | null], never> | undefined;
 } & {

package/dist/server/queries/settings/account-info-query.js

@@ -1,12 +1,54 @@
-import { authQueryKeys as e } from "@better-auth-ui/core";
-import { queryOptions as t } from "@tanstack/react-query";
-//#region src/server/queries/settings/account-info-query.ts
-function n(n, r, i) {
-	return t({
-		queryKey: e.accountInfo(r, i?.query),
-		queryFn: () => n.api.accountInfo(i)
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { queryOptions } from "@tanstack/react-query";
+/**
+ * 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(auth, userId, params) {
+    const queryKey = authQueryKeys.accountInfo(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: () => auth.api.accountInfo(params)
+    });
+    return options;
 }
-var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
-//#endregion
-export { n as accountInfoOptions, r as ensureAccountInfo, a as fetchAccountInfo, i as prefetchAccountInfo };
+/**
+ * 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 = (queryClient, auth, userId, params) => 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 = (queryClient, auth, userId, params) => 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 = (queryClient, auth, userId, params) => queryClient.fetchQuery(accountInfoOptions(auth, userId, params));

package/dist/server/queries/settings/list-accounts-query.d.ts

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { APIError } from 'better-auth';
-import { AuthServer } from '../../../lib/auth-server';
+import { type DataTag, type QueryClient } 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];
@@ -12,8 +12,8 @@ export type ListAccount<TAuth extends AuthServer = AuthServer> = NonNullable<Lis
  *   the key matches the client-side `listAccountsOptions` for SSR hydration.
  * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
  */
-export declare function listAccountsOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: ListAccountsParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null], never> | undefined;
+export declare function listAccountsOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: ListAccountsParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null], never> | undefined;
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null] & {
         [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listUserAccounts"]>>;

package/dist/server/queries/settings/list-accounts-query.js

@@ -1,12 +1,54 @@
-import { authQueryKeys as e } from "@better-auth-ui/core";
-import { queryOptions as t } from "@tanstack/react-query";
-//#region src/server/queries/settings/list-accounts-query.ts
-function n(n, r, i) {
-	return t({
-		queryKey: e.listAccounts(r, i?.query),
-		queryFn: () => n.api.listUserAccounts(i)
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { queryOptions } from "@tanstack/react-query";
+/**
+ * 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(auth, userId, params) {
+    const queryKey = authQueryKeys.listAccounts(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: () => auth.api.listUserAccounts(params)
+    });
+    return options;
 }
-var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
-//#endregion
-export { r as ensureListAccounts, a as fetchListAccounts, n as listAccountsOptions, i as prefetchListAccounts };
+/**
+ * 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 = (queryClient, auth, userId, params) => 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 = (queryClient, auth, userId, params) => 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 = (queryClient, auth, userId, params) => queryClient.fetchQuery(listAccountsOptions(auth, userId, params));

package/dist/server/queries/settings/list-sessions-query.d.ts

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { APIError } from 'better-auth';
-import { AuthServer } from '../../../lib/auth-server';
+import { type DataTag, type QueryClient } 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];
@@ -12,8 +12,8 @@ export type ListSession<TAuth extends AuthServer = AuthServer> = NonNullable<Lis
  *   the key matches the client-side `listSessionsOptions` for SSR hydration.
  * @param params - Parameters forwarded to `auth.api.listSessions`.
  */
-export declare function listSessionsOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: ListSessionsParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listSessions"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listSessions"]>>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listSessions"]>>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null], never> | undefined;
+export declare function listSessionsOptions<TAuth extends AuthServer>(auth: TAuth, userId: string, params: ListSessionsParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listSessions"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listSessions"]>>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listSessions"]>>, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null], never> | undefined;
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null] & {
         [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listSessions"]>>;

package/dist/server/queries/settings/list-sessions-query.js

@@ -1,12 +1,54 @@
-import { authQueryKeys as e } from "@better-auth-ui/core";
-import { queryOptions as t } from "@tanstack/react-query";
-//#region src/server/queries/settings/list-sessions-query.ts
-function n(n, r, i) {
-	return t({
-		queryKey: e.listSessions(r, i?.query),
-		queryFn: () => n.api.listSessions(i)
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { queryOptions } from "@tanstack/react-query";
+/**
+ * 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(auth, userId, params) {
+    const queryKey = authQueryKeys.listSessions(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: () => auth.api.listSessions(params)
+    });
+    return options;
 }
-var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
-//#endregion
-export { r as ensureListSessions, a as fetchListSessions, n as listSessionsOptions, i as prefetchListSessions };
+/**
+ * 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 = (queryClient, auth, userId, params) => 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 = (queryClient, auth, userId, params) => 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 = (queryClient, auth, userId, params) => queryClient.fetchQuery(listSessionsOptions(auth, userId, params));

package/dist/server.d.ts

@@ -1,7 +1,15 @@
-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';
+export type * from "./lib/auth-server";
+export * from "./server/queries/api-key/list-api-keys-query";
+export * from "./server/queries/auth/session-query";
+export * from "./server/queries/multi-session/list-device-sessions-query";
+export * from "./server/queries/organization/active-organization-query";
+export * from "./server/queries/organization/full-organization-query";
+export * from "./server/queries/organization/has-permission-query";
+export * from "./server/queries/organization/list-invitations-query";
+export * from "./server/queries/organization/list-members-query";
+export * from "./server/queries/organization/list-organizations-query";
+export * from "./server/queries/organization/list-user-invitations-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/server.js

@@ -1,7 +1,14 @@
-import { ensureSession as e, fetchSession as t, prefetchSession as n, sessionOptions as r } from "./server/queries/auth/session-query.js";
-import { ensureListDeviceSessions as i, fetchListDeviceSessions as a, listDeviceSessionsOptions as o, prefetchListDeviceSessions as s } from "./server/queries/multi-session/list-device-sessions-query.js";
-import { ensureListPasskeys as c, fetchListPasskeys as l, listPasskeysOptions as u, prefetchListPasskeys as d } from "./server/queries/passkey/list-passkeys-query.js";
-import { accountInfoOptions as f, ensureAccountInfo as p, fetchAccountInfo as m, prefetchAccountInfo as h } from "./server/queries/settings/account-info-query.js";
-import { ensureListAccounts as g, fetchListAccounts as _, listAccountsOptions as v, prefetchListAccounts as y } from "./server/queries/settings/list-accounts-query.js";
-import { ensureListSessions as b, fetchListSessions as x, listSessionsOptions as S, prefetchListSessions as C } from "./server/queries/settings/list-sessions-query.js";
-export { f as accountInfoOptions, p as ensureAccountInfo, g as ensureListAccounts, i as ensureListDeviceSessions, c as ensureListPasskeys, b as ensureListSessions, e as ensureSession, m as fetchAccountInfo, _ as fetchListAccounts, a as fetchListDeviceSessions, l as fetchListPasskeys, x as fetchListSessions, t as fetchSession, v as listAccountsOptions, o as listDeviceSessionsOptions, u as listPasskeysOptions, S as listSessionsOptions, h as prefetchAccountInfo, y as prefetchListAccounts, s as prefetchListDeviceSessions, d as prefetchListPasskeys, C as prefetchListSessions, n as prefetchSession, r as sessionOptions };
+export * from "./server/queries/api-key/list-api-keys-query";
+export * from "./server/queries/auth/session-query";
+export * from "./server/queries/multi-session/list-device-sessions-query";
+export * from "./server/queries/organization/active-organization-query";
+export * from "./server/queries/organization/full-organization-query";
+export * from "./server/queries/organization/has-permission-query";
+export * from "./server/queries/organization/list-invitations-query";
+export * from "./server/queries/organization/list-members-query";
+export * from "./server/queries/organization/list-organizations-query";
+export * from "./server/queries/organization/list-user-invitations-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";