@better-auth-ui/solid 1.6.19

package/src/mutations/passkey/add-passkey-mutation.ts

@@ -0,0 +1,40 @@
+import {
+  passkeyMutationKeys,
+  passkeyQueryKeys
+} from "@better-auth-ui/core/plugins"
+import type { PasskeyAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+import { useSessionScopedMutation } from "../use-session-scoped-mutation"
+
+export type AddPasskeyParams<TAuthClient extends PasskeyAuthClient> =
+  Parameters<TAuthClient["passkey"]["addPasskey"]>[0]
+
+export type AddPasskeyOptions = Parameters<
+  typeof useSessionScopedMutation<
+    PasskeyAuthClient,
+    PasskeyAuthClient["passkey"]["addPasskey"],
+    typeof passkeyMutationKeys.addPasskey
+  >
+>[4]
+
+export function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.passkey.addPasskey,
+    passkeyMutationKeys.addPasskey
+  )
+}
+
+export function useAddPasskey<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  options?: AddPasskeyOptions
+) {
+  return useSessionScopedMutation(
+    authClient,
+    authClient.passkey.addPasskey,
+    passkeyMutationKeys.addPasskey,
+    (userId) => ({ awaits: [passkeyQueryKeys.lists(userId)] }),
+    options
+  )
+}

package/src/mutations/passkey/delete-passkey-mutation.ts

@@ -0,0 +1,40 @@
+import {
+  passkeyMutationKeys,
+  passkeyQueryKeys
+} from "@better-auth-ui/core/plugins"
+import type { PasskeyAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+import { useSessionScopedMutation } from "../use-session-scoped-mutation"
+
+export type DeletePasskeyParams<TAuthClient extends PasskeyAuthClient> =
+  Parameters<TAuthClient["passkey"]["deletePasskey"]>[0]
+
+export type DeletePasskeyOptions = Parameters<
+  typeof useSessionScopedMutation<
+    PasskeyAuthClient,
+    PasskeyAuthClient["passkey"]["deletePasskey"],
+    typeof passkeyMutationKeys.deletePasskey
+  >
+>[4]
+
+export function deletePasskeyOptions<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.passkey.deletePasskey,
+    passkeyMutationKeys.deletePasskey
+  )
+}
+
+export function useDeletePasskey<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  options?: DeletePasskeyOptions
+) {
+  return useSessionScopedMutation(
+    authClient,
+    authClient.passkey.deletePasskey,
+    passkeyMutationKeys.deletePasskey,
+    (userId) => ({ awaits: [passkeyQueryKeys.lists(userId)] }),
+    options
+  )
+}

package/src/mutations/passkey/sign-in-passkey-mutation.ts

@@ -0,0 +1,17 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import { passkeyMutationKeys } from "@better-auth-ui/core/plugins"
+import type { PasskeyAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type SignInPasskeyParams<TAuthClient extends PasskeyAuthClient> =
+  Parameters<TAuthClient["signIn"]["passkey"]>[0]
+
+export function signInPasskeyOptions<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.signIn.passkey,
+    passkeyMutationKeys.signIn,
+    { awaits: [authQueryKeys.session] }
+  )
+}

package/src/mutations/settings/change-email-mutation.ts

@@ -0,0 +1,17 @@
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type ChangeEmailParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["changeEmail"]
+>[0]
+
+export function changeEmailOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.changeEmail,
+    authMutationKeys.changeEmail,
+    { awaits: [authQueryKeys.session] }
+  )
+}

package/src/mutations/settings/change-password-mutation.ts

@@ -0,0 +1,16 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type ChangePasswordParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["changePassword"]
+>[0]
+
+export function changePasswordOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.changePassword,
+    authMutationKeys.changePassword
+  )
+}

package/src/mutations/settings/delete-user-mutation.ts

@@ -0,0 +1,16 @@
+import { deleteUserMutationKeys } from "@better-auth-ui/core/plugins"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type DeleteUserParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["deleteUser"]
+>[0]
+
+export function deleteUserOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.deleteUser,
+    deleteUserMutationKeys.deleteUser
+  )
+}

package/src/mutations/settings/link-social-mutation.ts

@@ -0,0 +1,16 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type LinkSocialParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["linkSocial"]
+>[0]
+
+export function linkSocialOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.linkSocial,
+    authMutationKeys.linkSocial
+  )
+}

package/src/mutations/settings/revoke-session-mutation.ts

@@ -0,0 +1,38 @@
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+import { useSessionScopedMutation } from "../use-session-scoped-mutation"
+
+export type RevokeSessionParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["revokeSession"]
+>[0]
+
+export type RevokeSessionOptions = Parameters<
+  typeof useSessionScopedMutation<
+    AuthClient,
+    AuthClient["revokeSession"],
+    typeof authMutationKeys.revokeSession
+  >
+>[4]
+
+export function revokeSessionOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.revokeSession,
+    authMutationKeys.revokeSession
+  )
+}
+
+export function useRevokeSession<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options?: RevokeSessionOptions
+) {
+  return useSessionScopedMutation(
+    authClient,
+    authClient.revokeSession,
+    authMutationKeys.revokeSession,
+    (userId) => ({ awaits: [authQueryKeys.listSessions(userId)] }),
+    options
+  )
+}

package/src/mutations/settings/unlink-account-mutation.ts

@@ -0,0 +1,38 @@
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+import { useSessionScopedMutation } from "../use-session-scoped-mutation"
+
+export type UnlinkAccountParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["unlinkAccount"]
+>[0]
+
+export type UnlinkAccountOptions = Parameters<
+  typeof useSessionScopedMutation<
+    AuthClient,
+    AuthClient["unlinkAccount"],
+    typeof authMutationKeys.unlinkAccount
+  >
+>[4]
+
+export function unlinkAccountOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.unlinkAccount,
+    authMutationKeys.unlinkAccount
+  )
+}
+
+export function useUnlinkAccount<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options?: UnlinkAccountOptions
+) {
+  return useSessionScopedMutation(
+    authClient,
+    authClient.unlinkAccount,
+    authMutationKeys.unlinkAccount,
+    (userId) => ({ awaits: [authQueryKeys.listAccounts(userId)] }),
+    options
+  )
+}

package/src/mutations/settings/update-user-mutation.ts

@@ -0,0 +1,17 @@
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
+import type { AuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type UpdateUserParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["updateUser"]
+>[0]
+
+export function updateUserOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.updateUser,
+    authMutationKeys.updateUser,
+    { awaits: [authQueryKeys.session] }
+  )
+}

package/src/mutations/use-session-scoped-mutation.ts

@@ -0,0 +1,64 @@
+import {
+  type CreateMutationOptions,
+  createMutation,
+  type MutationKey
+} from "@tanstack/solid-query"
+import type { BetterFetchError } from "better-auth/client"
+import type { AuthClient } from "../lib/auth-client"
+import { useSession } from "../queries/auth/session-query"
+import {
+  type AuthMutationMeta,
+  createAuthMutationOptions,
+  type MutationMethod
+} from "./create-auth-mutation"
+
+export type SessionScopedMutationOptions<TMethod extends MutationMethod> = Omit<
+  CreateMutationOptions<
+    Awaited<ReturnType<TMethod>>,
+    BetterFetchError,
+    Parameters<TMethod>[0]
+  >,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+/**
+ * Create a mutation whose `meta` is derived from the current session's userId.
+ *
+ * This mirrors `useOrganizationMutation` for non-org domains: it reads the
+ * session reactively and passes the userId to a meta factory function so that
+ * `MutationInvalidator` can invalidate the correct scoped query keys.
+ *
+ * NOTE: `options` must NEVER contain a `meta` property — the type Omit
+ * enforces this at the type level, and the explicit `meta:` assignment below
+ * will silently override anything passed via options.
+ */
+export function useSessionScopedMutation<
+  TAuthClient extends AuthClient,
+  TMethod extends MutationMethod,
+  const TMutationKey extends MutationKey
+>(
+  authClient: TAuthClient,
+  authFn: TMethod,
+  mutationKey: TMutationKey,
+  meta: (userId: string | undefined) => AuthMutationMeta,
+  options?: SessionScopedMutationOptions<TMethod>
+) {
+  const session = useSession(authClient)
+
+  return createMutation(() => {
+    const userId = (session.data as { user?: { id?: string } } | undefined)
+      ?.user?.id
+
+    if (!userId) {
+      console.debug(
+        `[useSessionScopedMutation] userId is undefined for mutation "${String(mutationKey)}". Cache invalidation will be a no-op until the session loads.`
+      )
+    }
+
+    return {
+      ...createAuthMutationOptions(authFn, mutationKey),
+      ...options,
+      meta: meta(userId)
+    }
+  })
+}

package/src/mutations/username/is-username-available-mutation.ts

@@ -0,0 +1,15 @@
+import { usernameMutationKeys } from "@better-auth-ui/core/plugins"
+import type { UsernameAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type IsUsernameAvailableParams<TAuthClient extends UsernameAuthClient> =
+  Parameters<TAuthClient["isUsernameAvailable"]>[0]
+
+export function isUsernameAvailableOptions<
+  TAuthClient extends UsernameAuthClient
+>(authClient: TAuthClient) {
+  return createAuthMutationOptions(
+    authClient.isUsernameAvailable,
+    usernameMutationKeys.isUsernameAvailable
+  )
+}

package/src/mutations/username/sign-in-username-mutation.ts

@@ -0,0 +1,17 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import { usernameMutationKeys } from "@better-auth-ui/core/plugins"
+import type { UsernameAuthClient } from "../../lib/auth-client"
+import { createAuthMutationOptions } from "../create-auth-mutation"
+
+export type SignInUsernameParams<TAuthClient extends UsernameAuthClient> =
+  Parameters<TAuthClient["signIn"]["username"]>[0]
+
+export function signInUsernameOptions<TAuthClient extends UsernameAuthClient>(
+  authClient: TAuthClient
+) {
+  return createAuthMutationOptions(
+    authClient.signIn.username,
+    usernameMutationKeys.signIn,
+    { awaits: [authQueryKeys.session] }
+  )
+}

package/src/plugins/captcha-plugin.tsx

@@ -0,0 +1,64 @@
+import { createAuthPlugin } from "@better-auth-ui/core"
+import { type Component, onCleanup } from "solid-js"
+import { useFetchOptions } from "../lib/fetch-options-provider"
+
+/** Props passed to the consumer's `render` component. */
+export type CaptchaRenderProps = {
+  /** Call once the user solves the captcha. */
+  setToken: (token: string) => void
+  /** Call on error/expire to clear the token. */
+  clearToken: () => void
+  /**
+   * Register your widget's `reset()`. Forms call it after a failed
+   * submission since captcha tokens are single-use. Pass `null` on cleanup.
+   */
+  setReset: (reset: (() => void) | null) => void
+}
+
+export type CaptchaPluginOptions = {
+  /** Renders the captcha widget. Wire `setToken`, `clearToken`, and `setReset`. */
+  render: Component<CaptchaRenderProps>
+}
+
+/**
+ * Provider-agnostic captcha plugin. Forwards the resolved token via the
+ * `x-captcha-response` header on Better Auth requests.
+ */
+export const captchaPlugin = createAuthPlugin(
+  "captcha",
+  ({ render: Render }: CaptchaPluginOptions) => {
+    const CaptchaWidget = () => {
+      const { setFetchOptions, registerReset } = useFetchOptions()
+
+      const setToken = (token: string) => {
+        setFetchOptions({ headers: { "x-captcha-response": token } })
+      }
+
+      const clearToken = () => {
+        setFetchOptions(undefined)
+      }
+
+      const setReset = (reset: (() => void) | null) => {
+        registerReset(reset)
+      }
+
+      onCleanup(() => {
+        setFetchOptions(undefined)
+        registerReset(null)
+      })
+
+      return (
+        <Render
+          setToken={setToken}
+          clearToken={clearToken}
+          setReset={setReset}
+        />
+      )
+    }
+
+    return {
+      render: Render,
+      captchaComponent: CaptchaWidget
+    }
+  }
+)

package/src/plugins.ts

@@ -0,0 +1,2 @@
+export type { AuthPlugin } from "./lib/auth-plugin"
+export * from "./plugins/captcha-plugin"

package/src/queries/api-key/list-api-keys-query.ts

@@ -0,0 +1,93 @@
+import { apiKeyQueryKeys } from "@better-auth-ui/core/plugins"
+import type { QueryClient } from "@tanstack/solid-query"
+import type { ApiKeyAuthClient, InferData } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import {
+  createUserScopedOptions,
+  createUserScopedQuery,
+  ensureUserScopedQuery,
+  fetchUserScopedQuery,
+  getSessionUserId,
+  prefetchUserScopedQuery
+} from "../create-user-scoped-query"
+
+export type ListApiKeysData<TAuthClient extends ApiKeyAuthClient> = InferData<
+  TAuthClient["apiKey"]["list"]
+>
+export type ListApiKeysParams<TAuthClient extends ApiKeyAuthClient> =
+  Parameters<TAuthClient["apiKey"]["list"]>[0]
+export type ListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> = Omit<
+  ReturnType<typeof listApiKeysOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListApiKeysParams<TAuthClient>
+) {
+  return createUserScopedOptions(
+    apiKeyQueryKeys.list(userId, params?.query),
+    authClient.apiKey.list,
+    params
+  )
+}
+
+export const ensureListApiKeys = <TAuthClient extends ApiKeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListApiKeysParams<TAuthClient>
+) =>
+  ensureUserScopedQuery(
+    queryClient,
+    apiKeyQueryKeys.list(userId, params?.query),
+    authClient.apiKey.list,
+    params
+  )
+
+export const prefetchListApiKeys = <TAuthClient extends ApiKeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListApiKeysParams<TAuthClient>
+) =>
+  prefetchUserScopedQuery(
+    queryClient,
+    apiKeyQueryKeys.list(userId, params?.query),
+    authClient.apiKey.list,
+    params
+  )
+
+export const fetchListApiKeys = <TAuthClient extends ApiKeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListApiKeysParams<TAuthClient>
+) =>
+  fetchUserScopedQuery(
+    queryClient,
+    apiKeyQueryKeys.list(userId, params?.query),
+    authClient.apiKey.list,
+    params
+  )
+
+export type UseListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> =
+  ListApiKeysOptions<TAuthClient> & ListApiKeysParams<TAuthClient>
+
+export function useListApiKeys<TAuthClient extends ApiKeyAuthClient>(
+  authClient: TAuthClient,
+  options: UseListApiKeysOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+  const userId = () => getSessionUserId(session)
+  const { query, fetchOptions, ...queryOptionsRest } = options
+
+  return createUserScopedQuery(
+    () => apiKeyQueryKeys.list(userId(), query),
+    authClient.apiKey.list,
+    () => ({ query, fetchOptions }) as ListApiKeysParams<TAuthClient>,
+    () => Boolean(userId()),
+    () => queryOptionsRest
+  )
+}

package/src/queries/auth/session-query.ts

@@ -0,0 +1,81 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  createQuery,
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/solid-query"
+import type { BetterFetchError } from "better-auth/client"
+import type { AuthClient, InferData } from "../../lib/auth-client"
+
+export type SessionData<TAuthClient extends AuthClient = AuthClient> =
+  InferData<TAuthClient["getSession"]>
+
+export type Session<TAuthClient extends AuthClient = AuthClient> = NonNullable<
+  SessionData<TAuthClient>
+>
+
+export type SessionParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["getSession"]
+>[0]
+
+export type SessionOptions<TAuthClient extends AuthClient> = Omit<
+  ReturnType<typeof sessionOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function sessionOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  params?: SessionParams<TAuthClient>
+) {
+  type TData = SessionData<TAuthClient>
+  const queryKey = authQueryKeys.session
+
+  const options = queryOptions<TData, BetterFetchError>({
+    queryKey,
+    queryFn: ({ signal }) =>
+      authClient.getSession({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+      }) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureSession = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  params?: SessionParams<TAuthClient>
+) => queryClient.ensureQueryData(sessionOptions(authClient, params) as never)
+
+export const prefetchSession = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  params?: SessionParams<TAuthClient>
+) => queryClient.prefetchQuery(sessionOptions(authClient, params) as never)
+
+export const fetchSession = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  params?: SessionParams<TAuthClient>
+) => queryClient.fetchQuery(sessionOptions(authClient, params) as never)
+
+export type UseSessionOptions<TAuthClient extends AuthClient> =
+  SessionOptions<TAuthClient> & SessionParams<TAuthClient>
+
+export function useSession<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options: UseSessionOptions<TAuthClient> = {}
+) {
+  return createQuery(() => {
+    const { query, fetchOptions, ...queryOptions } = options
+
+    return {
+      ...sessionOptions(authClient, { query, fetchOptions }),
+      ...queryOptions
+    }
+  })
+}

package/src/queries/auth-query-options.ts

@@ -0,0 +1,57 @@
+import {
+  type CreateQueryOptions,
+  type DataTag,
+  type QueryKey,
+  queryOptions
+} from "@tanstack/solid-query"
+import type { BetterFetchError, BetterFetchOption } from "better-auth/client"
+
+export type AuthQueryFn<TData = unknown> = (params: {
+  query?: Record<string, unknown>
+  fetchOptions?: BetterFetchOption
+}) => Promise<{ data: TData }>
+
+export type AuthQueryFnData<TFn> =
+  TFn extends AuthQueryFn<infer TData> ? TData : never
+
+export type AuthQueryKey<
+  TFn extends AuthQueryFn = AuthQueryFn,
+  TPrefix extends QueryKey = QueryKey
+> = readonly [...TPrefix, NonNullable<Parameters<TFn>[0]>["query"] | null]
+
+export type AuthQueryOptions<
+  TFn extends AuthQueryFn = AuthQueryFn,
+  TPrefix extends QueryKey = QueryKey
+> = Omit<
+  CreateQueryOptions<
+    AuthQueryFnData<TFn>,
+    BetterFetchError,
+    AuthQueryFnData<TFn>,
+    AuthQueryKey<TFn, TPrefix>
+  >,
+  "queryKey"
+> & {
+  queryKey: DataTag<
+    AuthQueryKey<TFn, TPrefix>,
+    AuthQueryFnData<TFn>,
+    BetterFetchError
+  >
+}
+
+export function authQueryOptions<
+  TFn extends AuthQueryFn,
+  const TPrefix extends QueryKey
+>(
+  authFn: TFn,
+  queryKey: TPrefix,
+  params?: Parameters<TFn>[0]
+): AuthQueryOptions<TFn, TPrefix> {
+  return queryOptions<AuthQueryFnData<TFn>, BetterFetchError>({
+    queryKey: [...queryKey, params?.query ?? null] as const,
+    queryFn: ({ signal }) =>
+      authFn({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+      }) as Promise<AuthQueryFnData<TFn>>
+  }) as AuthQueryOptions<TFn, TPrefix>
+}