@better-auth-ui/react 1.6.9 → 1.6.11

package/dist/mutations/settings/revoke-session-mutation.js

@@ -1,39 +0,0 @@
-import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core";
-import { mutationOptions, useMutation } from "@tanstack/react-query";
-import { useSession } from "../../queries/auth/session-query";
-/**
- * Mutation options factory for revoking a user session.
- *
- * @param authClient - The Better Auth client.
- */
-export function revokeSessionOptions(authClient) {
-    const mutationKey = authMutationKeys.revokeSession;
-    const mutationFn = (params) => authClient.revokeSession({
-        ...params,
-        fetchOptions: { ...params?.fetchOptions, throw: true }
-    });
-    return mutationOptions({
-        mutationKey,
-        mutationFn
-    });
-}
-/**
- * Create a mutation for revoking a user session.
- *
- * On success, `MutationInvalidator` awaits invalidation of the sessions
- * list (see `meta.awaits`).
- *
- * @param authClient - The Better Auth client.
- * @param options - React Query options forwarded to `useMutation`.
- */
-export function useRevokeSession(authClient, options, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    return useMutation({
-        ...revokeSessionOptions(authClient),
-        ...options,
-        meta: {
-            awaits: [authQueryKeys.listSessions(userId)]
-        }
-    }, queryClient);
-}

package/dist/mutations/settings/unlink-account-mutation.js

@@ -1,39 +0,0 @@
-import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core";
-import { mutationOptions, useMutation } from "@tanstack/react-query";
-import { useSession } from "../../queries/auth/session-query";
-/**
- * Mutation options factory for unlinking a social provider from the current user.
- *
- * @param authClient - The Better Auth client.
- */
-export function unlinkAccountOptions(authClient) {
-    const mutationKey = authMutationKeys.unlinkAccount;
-    const mutationFn = (params) => authClient.unlinkAccount({
-        ...params,
-        fetchOptions: { ...params?.fetchOptions, throw: true }
-    });
-    return mutationOptions({
-        mutationKey,
-        mutationFn
-    });
-}
-/**
- * Create a mutation for unlinking a social provider from the current user.
- *
- * On success, `MutationInvalidator` awaits invalidation of the linked
- * accounts list (see `meta.awaits`).
- *
- * @param authClient - The Better Auth client.
- * @param options - React Query options forwarded to `useMutation`.
- */
-export function useUnlinkAccount(authClient, options, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    return useMutation({
-        ...unlinkAccountOptions(authClient),
-        ...options,
-        meta: {
-            awaits: [authQueryKeys.listAccounts(userId)]
-        }
-    }, queryClient);
-}

package/dist/mutations/settings/update-user-mutation.js

@@ -1,36 +0,0 @@
-import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core";
-import { mutationOptions, useMutation } from "@tanstack/react-query";
-/**
- * Mutation options factory for updating the authenticated user's profile.
- *
- * @param authClient - The Better Auth client.
- */
-export function updateUserOptions(authClient) {
-    const mutationKey = authMutationKeys.updateUser;
-    const mutationFn = (params) => authClient.updateUser({
-        ...params,
-        fetchOptions: { ...params?.fetchOptions, throw: true }
-    });
-    return mutationOptions({
-        mutationKey,
-        mutationFn
-    });
-}
-/**
- * Create a mutation for updating the authenticated user's profile.
- *
- * On success, `MutationInvalidator` awaits invalidation of the session
- * query so the updated user fields are reflected (see `meta.awaits`).
- *
- * @param authClient - The Better Auth client.
- * @param options - React Query options forwarded to `useMutation`.
- */
-export function useUpdateUser(authClient, options, queryClient) {
-    return useMutation({
-        ...updateUserOptions(authClient),
-        ...options,
-        meta: {
-            awaits: [authQueryKeys.session]
-        }
-    }, queryClient);
-}

package/dist/mutations/username/is-username-available-mutation.js

@@ -1,36 +0,0 @@
-import { usernameMutationKeys } from "@better-auth-ui/core/plugins";
-import { mutationOptions, useMutation } from "@tanstack/react-query";
-/**
- * Mutation options factory for checking username availability.
- *
- * Modeled as a mutation because callers typically trigger the check on
- * user action (debounced input, form submit) rather than on mount.
- *
- * @param authClient - The Better Auth client.
- */
-export function isUsernameAvailableOptions(authClient) {
-    const mutationKey = usernameMutationKeys.isUsernameAvailable;
-    const mutationFn = (params) => authClient.isUsernameAvailable({
-        ...params,
-        fetchOptions: { ...params?.fetchOptions, throw: true }
-    });
-    return mutationOptions({
-        mutationKey,
-        mutationFn
-    });
-}
-/**
- * Create a mutation for checking whether a username is available.
- *
- * Wraps `authClient.isUsernameAvailable` and forwards React Query mutation
- * options such as `onSuccess`, `onError`, and `retry`.
- *
- * @param authClient - The Better Auth client with the username plugin.
- * @param options - React Query options forwarded to `useMutation`.
- */
-export function useIsUsernameAvailable(authClient, options) {
-    return useMutation({
-        ...isUsernameAvailableOptions(authClient),
-        ...options
-    });
-}

package/dist/mutations/username/sign-in-username-mutation.js

@@ -1,37 +0,0 @@
-import { authQueryKeys } from "@better-auth-ui/core";
-import { usernameMutationKeys } from "@better-auth-ui/core/plugins";
-import { mutationOptions, useMutation } from "@tanstack/react-query";
-/**
- * Mutation options factory for username/password sign-in.
- *
- * @param authClient - The Better Auth client.
- */
-export function signInUsernameOptions(authClient) {
-    const mutationKey = usernameMutationKeys.signIn;
-    const mutationFn = (params) => authClient.signIn.username({
-        ...params,
-        fetchOptions: { ...params?.fetchOptions, throw: true }
-    });
-    return mutationOptions({
-        mutationKey,
-        mutationFn
-    });
-}
-/**
- * Create a mutation for username/password sign-in.
- *
- * On success, `MutationInvalidator` awaits invalidation of the session
- * query so the new session is refetched (see `meta.awaits`).
- *
- * @param authClient - The Better Auth client with the username plugin.
- * @param options - React Query options forwarded to `useMutation`.
- */
-export function useSignInUsername(authClient, options, queryClient) {
-    return useMutation({
-        ...signInUsernameOptions(authClient),
-        ...options,
-        meta: {
-            awaits: [authQueryKeys.session]
-        }
-    }, queryClient);
-}

package/dist/plugins/captcha-plugin.js

@@ -1,34 +0,0 @@
-"use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createAuthPlugin } from "@better-auth-ui/core";
-import { useCallback, useEffect } from "react";
-import { useFetchOptions } from "../components/auth/fetch-options-provider";
-import { useAuthPlugin } from "../hooks/use-auth-plugin";
-function CaptchaWidget() {
-    const { render: Render } = useAuthPlugin(captchaPlugin);
-    const { setFetchOptions, registerReset } = useFetchOptions();
-    const setToken = useCallback((token) => {
-        setFetchOptions({ headers: { "x-captcha-response": token } });
-    }, [setFetchOptions]);
-    const clearToken = useCallback(() => {
-        setFetchOptions(undefined);
-    }, [setFetchOptions]);
-    const setReset = useCallback((reset) => {
-        registerReset(reset);
-    }, [registerReset]);
-    useEffect(() => {
-        return () => {
-            setFetchOptions(undefined);
-            registerReset(null);
-        };
-    }, [setFetchOptions, registerReset]);
-    return (_jsx(Render, { setToken: setToken, clearToken: clearToken, setReset: setReset }));
-}
-/**
- * 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,
-    captchaComponent: _jsx(CaptchaWidget, {})
-}));

package/dist/queries/api-key/list-api-keys-query.js

@@ -1,54 +0,0 @@
-import { apiKeyQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-/**
- * Query options factory for the current user's API keys.
- *
- * Shares a query key with the server-side `listApiKeysOptions` from
- * `@better-auth-ui/react/server`, so SSR-hydrated data is reused from the
- * cache without an immediate refetch.
- *
- * @param authClient - The Better Auth client with the API key plugin.
- * @param userId - The current signed-in user's ID. Used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.apiKey.list`.
- */
-export function listApiKeysOptions(authClient, userId, params) {
-    const queryKey = apiKeyQueryKeys.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.apiKey.list({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-export const ensureListApiKeys = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listApiKeysOptions(authClient, userId, params));
-export const prefetchListApiKeys = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listApiKeysOptions(authClient, userId, params));
-export const fetchListApiKeys = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listApiKeysOptions(authClient, userId, params));
-/**
- * Subscribe to the current user's API keys via TanStack Query.
- *
- * Shares a query key with the server-side `listApiKeysOptions`, so
- * SSR-hydrated data is reused from the cache without an immediate refetch.
- * The query is gated on a signed-in user; while the session is loading or
- * absent, the underlying `queryFn` is replaced with `skipToken`.
- *
- * @param authClient - The Better Auth client with the API key plugin.
- * @param options - `apiKey.list` params merged with `useQuery` options.
- * @param queryClient - Optional custom `QueryClient`.
- */
-export function useListApiKeys(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptionsRest } = options;
-    const baseOptions = listApiKeysOptions(authClient, userId, {
-        query,
-        fetchOptions
-    });
-    return useQuery({
-        ...queryOptionsRest,
-        ...baseOptions,
-        queryFn: userId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

package/dist/queries/auth/session-query.js

@@ -1,72 +0,0 @@
-import { authQueryKeys } from "@better-auth-ui/core";
-import { queryOptions, useQuery } from "@tanstack/react-query";
-/**
- * Query options factory for the current session.
- *
- * Shares a query key with the server-side `sessionOptions` so that data
- * prefetched during SSR hydrates seamlessly into the client cache.
- *
- * @param authClient - The Better Auth client.
- * @param params - Parameters forwarded to `authClient.getSession`.
- */
-export function sessionOptions(authClient, params) {
-    const queryKey = authQueryKeys.session;
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.getSession({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-/**
- * Get the current session from the query cache, calling `fetchSession` under
- * the hood if no cached entry exists. Resolves with the session data, making
- * it ideal for loaders or `beforeLoad` guards.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param params - Parameters forwarded to `authClient.getSession`.
- */
-export const ensureSession = (queryClient, authClient, params) => queryClient.ensureQueryData(sessionOptions(authClient, params));
-/**
- * Prefetch the current session into the query cache. Behaves like
- * `fetchSession`, but does not throw on error and does not return the data —
- * use this to warm the cache without blocking navigation.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param params - Parameters forwarded to `authClient.getSession`.
- */
-export const prefetchSession = (queryClient, authClient, params) => queryClient.prefetchQuery(sessionOptions(authClient, params));
-/**
- * Fetch and cache the current session, 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.
- * @param authClient - The Better Auth client.
- * @param params - Parameters forwarded to `authClient.getSession`.
- */
-export const fetchSession = (queryClient, authClient, params) => queryClient.fetchQuery(sessionOptions(authClient, params));
-/**
- * Subscribe to the current session via TanStack Query.
- *
- * Shares a query key with the server-side `sessionOptions`, so SSR-hydrated
- * session data is reused from the cache without an immediate refetch.
- *
- * @param authClient - The Better Auth client.
- * @param options - `getSession` params (`query`, `fetchOptions`) merged
- *   with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
- * @param queryClient - Optional custom `QueryClient`. Defaults to the client
- *   from the nearest `QueryClientProvider`.
- */
-export function useSession(authClient, options = {}, queryClient) {
-    const { query, fetchOptions, ...queryOptions } = options;
-    return useQuery({
-        ...sessionOptions(authClient, { query, fetchOptions }),
-        ...queryOptions
-    }, queryClient);
-}

package/dist/queries/auth-query-options.js

@@ -1,21 +0,0 @@
-import { queryOptions } from "@tanstack/react-query";
-/**
- * Build `queryOptions` for a Better Auth endpoint.
- *
- * Injects React Query's `signal` and `throw: true` into `fetchOptions` so the
- * request is cancelled on unmount and errors surface as `BetterFetchError`
- * instead of `{ data, error }`.
- *
- * @param authFn - Better Auth client method (e.g. `authClient.getSession`).
- * @param queryKey - Scope prefix for the key. `params.query` is appended automatically.
- * @param params - Parameters forwarded to `authFn`.
- */
-export function authQueryOptions(authFn, queryKey, params) {
-    return queryOptions({
-        queryKey: [...queryKey, params?.query ?? null],
-        queryFn: ({ signal }) => authFn({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-}

package/dist/queries/multi-session/list-device-sessions-query.js

@@ -1,85 +0,0 @@
-import { multiSessionQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-/**
- * Query options factory for the current user's device sessions.
- *
- * @param authClient - The Better Auth client with the multi-session plugin.
- * @param userId - The current signed-in user's ID. Used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
- */
-export function listDeviceSessionsOptions(authClient, userId, params) {
-    const queryKey = multiSessionQueryKeys.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.multiSession.listDeviceSessions({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-/**
- * Get the current user's device sessions from the query cache, calling
- * `fetchListDeviceSessions` under the hood if no cached entry exists.
- * Resolves with the device session list, making it ideal for loaders or
- * `beforeLoad` guards.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client with the multi-session plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
- */
-export const ensureListDeviceSessions = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listDeviceSessionsOptions(authClient, userId, params));
-/**
- * Prefetch the current user's device sessions into the query cache. Behaves
- * like `fetchListDeviceSessions`, but does not throw on error and does not
- * return the data — use this to warm the cache without blocking navigation.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client with the multi-session plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
- */
-export const prefetchListDeviceSessions = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listDeviceSessionsOptions(authClient, userId, params));
-/**
- * Fetch and cache the current user's device 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.
- * @param authClient - The Better Auth client with the multi-session plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.multiSession.listDeviceSessions`.
- */
-export const fetchListDeviceSessions = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listDeviceSessionsOptions(authClient, userId, params));
-/**
- * Subscribe to the current user's device sessions (multi-session account
- * switcher) via TanStack Query.
- *
- * Shares a query key with the server-side `listDeviceSessionsOptions`, so
- * SSR-hydrated data is reused from the cache without an immediate refetch.
- * The query is gated on a signed-in user; while the session is loading or
- * absent, the underlying `queryFn` is replaced with `skipToken`.
- *
- * @param authClient - The Better Auth client with the multi-session plugin.
- * @param options - `listDeviceSessions` params (`query`, `fetchOptions`)
- *   merged with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
- * @param queryClient - Optional custom `QueryClient`. Defaults to the client
- *   from the nearest `QueryClientProvider`.
- */
-export function useListDeviceSessions(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptions } = options;
-    const baseOptions = listDeviceSessionsOptions(authClient, userId, {
-        query,
-        fetchOptions
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: userId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

package/dist/queries/organization/active-organization-query.js

@@ -1,37 +0,0 @@
-import { organizationPlugin, organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useAuthPlugin } from "../../hooks/use-auth-plugin";
-import { useSession } from "../auth/session-query";
-export function activeOrganizationOptions(authClient, userId, params) {
-    const queryKey = organizationQueryKeys.activeOrganization(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.organization.getFullOrganization({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-export const ensureActiveOrganization = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(activeOrganizationOptions(authClient, userId, params));
-export const prefetchActiveOrganization = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(activeOrganizationOptions(authClient, userId, params));
-export const fetchActiveOrganization = (queryClient, authClient, userId, params) => queryClient.fetchQuery(activeOrganizationOptions(authClient, userId, params));
-export function useActiveOrganization(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { slug } = useAuthPlugin(organizationPlugin);
-    const { query, fetchOptions, ...queryOptions } = options;
-    const baseOptions = activeOrganizationOptions(authClient, userId, {
-        fetchOptions,
-        query: slug ? { organizationSlug: slug } : query
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: slug === null
-            ? async () => null
-            : userId
-                ? baseOptions.queryFn
-                : skipToken
-    }, queryClient);
-}

package/dist/queries/organization/full-organization-query.js

@@ -1,31 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-export function fullOrganizationOptions(authClient, userId, params) {
-    const queryKey = organizationQueryKeys.fullDetail(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.organization.getFullOrganization({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-export const ensureFullOrganization = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(fullOrganizationOptions(authClient, userId, params));
-export const prefetchFullOrganization = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(fullOrganizationOptions(authClient, userId, params));
-export const fetchFullOrganization = (queryClient, authClient, userId, params) => queryClient.fetchQuery(fullOrganizationOptions(authClient, userId, params));
-export function useFullOrganization(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptions } = options;
-    const baseOptions = fullOrganizationOptions(authClient, userId, {
-        query,
-        fetchOptions
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: userId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

package/dist/queries/organization/has-permission-query.js

@@ -1,38 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-import { useActiveOrganization } from "./active-organization-query";
-export function hasPermissionOptions(authClient, userId, params) {
-    // `hasPermission` is the only org client method without a `query` field — its
-    // params are flat — so the "query" portion is everything except `fetchOptions`.
-    const { fetchOptions, ...query } = params;
-    const queryKey = organizationQueryKeys.permissions.has(userId, query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.organization.hasPermission({
-            ...query,
-            fetchOptions: { ...fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-export const ensureHasPermission = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(hasPermissionOptions(authClient, userId, params));
-export const prefetchHasPermission = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(hasPermissionOptions(authClient, userId, params));
-export const fetchHasPermission = (queryClient, authClient, userId, params) => queryClient.fetchQuery(hasPermissionOptions(authClient, userId, params));
-export function useHasPermission(authClient, options, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { fetchOptions, permissions, organizationId: optionsOrganizationId, ...queryOptions } = options;
-    const { data: activeOrganization } = useActiveOrganization(authClient, { enabled: !optionsOrganizationId }, queryClient);
-    const organizationId = optionsOrganizationId ?? activeOrganization?.id;
-    const baseOptions = hasPermissionOptions(authClient, userId, {
-        fetchOptions,
-        organizationId,
-        permissions
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

package/dist/queries/organization/index.js

@@ -1,7 +0,0 @@
-export * from "./active-organization-query";
-export * from "./full-organization-query";
-export * from "./has-permission-query";
-export * from "./list-invitations-query";
-export * from "./list-members-query";
-export * from "./list-organizations-query";
-export * from "./list-user-invitations-query";

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

@@ -1,37 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-import { useActiveOrganization } from "./active-organization-query";
-export function listOrganizationInvitationsOptions(authClient, userId, params) {
-    const queryKey = organizationQueryKeys.invitations.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.organization.listInvitations({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-export const ensureListOrganizationInvitations = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listOrganizationInvitationsOptions(authClient, userId, params));
-export const prefetchListOrganizationInvitations = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listOrganizationInvitationsOptions(authClient, userId, params));
-export const fetchListOrganizationInvitations = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listOrganizationInvitationsOptions(authClient, userId, params));
-export function useListOrganizationInvitations(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptions } = options;
-    const { data: activeOrganization } = useActiveOrganization(authClient, { enabled: !query?.organizationId }, queryClient);
-    const organizationId = query?.organizationId ?? activeOrganization?.id;
-    const baseOptions = listOrganizationInvitationsOptions(authClient, userId, {
-        query: {
-            ...query,
-            organizationId
-        },
-        fetchOptions
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

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

@@ -1,37 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-import { useActiveOrganization } from "./active-organization-query";
-export function listOrganizationMembersOptions(authClient, userId, params) {
-    const queryKey = organizationQueryKeys.members.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.organization.listMembers({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-export const ensureListOrganizationMembers = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listOrganizationMembersOptions(authClient, userId, params));
-export const prefetchListOrganizationMembers = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listOrganizationMembersOptions(authClient, userId, params));
-export const fetchListOrganizationMembers = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listOrganizationMembersOptions(authClient, userId, params));
-export function useListOrganizationMembers(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptions } = options;
-    const { data: activeOrganization } = useActiveOrganization(authClient, { enabled: !query?.organizationId }, queryClient);
-    const organizationId = query?.organizationId ?? activeOrganization?.id;
-    const baseOptions = listOrganizationMembersOptions(authClient, userId, {
-        query: {
-            ...query,
-            organizationId
-        },
-        fetchOptions
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}