@better-auth-ui/react 1.6.7 → 1.6.9

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

@@ -0,0 +1,37 @@
+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.d.ts

@@ -0,0 +1,37 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client";
+export type FullOrganizationData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = InferData<TAuthClient["organization"]["getFullOrganization"]>;
+export type FullOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["getFullOrganization"]>[0];
+export type FullOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof fullOrganizationOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function fullOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["organization"]["getFullOrganization"]>, BetterFetchError, InferData<TAuthClient["organization"]["getFullOrganization"]>, readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+    membersLimit?: string | number | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["organization"]["getFullOrganization"]>, readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: InferData<TAuthClient["organization"]["getFullOrganization"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], InferData<TAuthClient["organization"]["getFullOrganization"]>, BetterFetchError>;
+};
+export declare const ensureFullOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["getFullOrganization"]>>;
+export declare const prefetchFullOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>) => Promise<void>;
+export declare const fetchFullOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["getFullOrganization"]>>;
+export type UseFullOrganizationOptions<TAuthClient extends OrganizationAuthClient> = FullOrganizationOptions<TAuthClient> & FullOrganizationParams<TAuthClient>;
+export declare function useFullOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseFullOrganizationOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["organization"]["getFullOrganization"]>>, BetterFetchError>;

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

@@ -0,0 +1,31 @@
+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.d.ts

@@ -0,0 +1,21 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client";
+export type HasPermissionData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = InferData<TAuthClient["organization"]["hasPermission"]>;
+export type HasPermissionParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["hasPermission"]>[0];
+export type HasPermissionOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof hasPermissionOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function hasPermissionOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["organization"]["hasPermission"]>, BetterFetchError, InferData<TAuthClient["organization"]["hasPermission"]>, readonly ["auth", "user", string | undefined, "organization", "permissions", "has", Omit<HasPermissionParams<TAuthClient>, "fetchOptions"> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["organization"]["hasPermission"]>, readonly ["auth", "user", string | undefined, "organization", "permissions", "has", Omit<HasPermissionParams<TAuthClient>, "fetchOptions"> | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "permissions", "has", Omit<HasPermissionParams<TAuthClient>, "fetchOptions"> | null] & {
+        [dataTagSymbol]: InferData<TAuthClient["organization"]["hasPermission"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "permissions", "has", Omit<HasPermissionParams<TAuthClient>, "fetchOptions"> | null], InferData<TAuthClient["organization"]["hasPermission"]>, BetterFetchError>;
+};
+export declare const ensureHasPermission: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["hasPermission"]>>;
+export declare const prefetchHasPermission: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>) => Promise<void>;
+export declare const fetchHasPermission: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["hasPermission"]>>;
+export type UseHasPermissionOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = HasPermissionOptions<TAuthClient> & HasPermissionParams<TAuthClient>;
+export declare function useHasPermission<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options: UseHasPermissionOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["organization"]["hasPermission"]>>, BetterFetchError>;

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

@@ -0,0 +1,38 @@
+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.d.ts

@@ -0,0 +1,7 @@
+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/index.js

@@ -0,0 +1,7 @@
+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.d.ts

@@ -0,0 +1,29 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client";
+export type ListOrganizationInvitationsData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = InferData<TAuthClient["organization"]["listInvitations"]>;
+export type ListOrganizationInvitationsParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["listInvitations"]>[0];
+export type ListOrganizationInvitationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof listOrganizationInvitationsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listOrganizationInvitationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["organization"]["listInvitations"]>, BetterFetchError, InferData<TAuthClient["organization"]["listInvitations"]>, readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+    organizationId?: string | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["organization"]["listInvitations"]>, readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+        organizationId?: string | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+        organizationId?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: InferData<TAuthClient["organization"]["listInvitations"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+        organizationId?: string | undefined;
+    } | null], InferData<TAuthClient["organization"]["listInvitations"]>, BetterFetchError>;
+};
+export declare const ensureListOrganizationInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["listInvitations"]>>;
+export declare const prefetchListOrganizationInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListOrganizationInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["listInvitations"]>>;
+export type UseListOrganizationInvitationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListOrganizationInvitationsOptions<TAuthClient> & ListOrganizationInvitationsParams<TAuthClient>;
+export declare function useListOrganizationInvitations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationInvitationsOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["organization"]["listInvitations"]>>, BetterFetchError>;

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

@@ -0,0 +1,37 @@
+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.d.ts

@@ -0,0 +1,61 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client";
+export type ListOrganizationMembersData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = InferData<TAuthClient["organization"]["listMembers"]>;
+export type ListOrganizationMembersParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["listMembers"]>[0];
+export type ListOrganizationMembersOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof listOrganizationMembersOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listOrganizationMembersOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["organization"]["listMembers"]>, BetterFetchError, InferData<TAuthClient["organization"]["listMembers"]>, readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+    limit?: string | number | undefined;
+    offset?: string | number | undefined;
+    sortBy?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+    filterField?: string | undefined;
+    filterValue?: string | number | boolean | string[] | number[] | undefined;
+    filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["organization"]["listMembers"]>, readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+        filterField?: string | undefined;
+        filterValue?: string | number | boolean | string[] | number[] | undefined;
+        filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+        filterField?: string | undefined;
+        filterValue?: string | number | boolean | string[] | number[] | undefined;
+        filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: InferData<TAuthClient["organization"]["listMembers"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+        filterField?: string | undefined;
+        filterValue?: string | number | boolean | string[] | number[] | undefined;
+        filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+    } | null], InferData<TAuthClient["organization"]["listMembers"]>, BetterFetchError>;
+};
+export declare const ensureListOrganizationMembers: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["listMembers"]>>;
+export declare const prefetchListOrganizationMembers: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>) => Promise<void>;
+export declare const fetchListOrganizationMembers: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["listMembers"]>>;
+export type UseListOrganizationMembersOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListOrganizationMembersOptions<TAuthClient> & ListOrganizationMembersParams<TAuthClient>;
+export declare function useListOrganizationMembers<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationMembersOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["organization"]["listMembers"]>>, BetterFetchError>;

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

@@ -0,0 +1,37 @@
+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);
+}

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

@@ -0,0 +1,22 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client";
+export type ListOrganizationsData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = InferData<TAuthClient["organization"]["list"]>;
+export type ListOrganization<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = NonNullable<ListOrganizationsData<TAuthClient>>[number];
+export type ListOrganizationsParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["list"]>[0];
+export type ListOrganizationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof listOrganizationsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listOrganizationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationsParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["organization"]["list"]>, BetterFetchError, InferData<TAuthClient["organization"]["list"]>, readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["organization"]["list"]>, 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]: InferData<TAuthClient["organization"]["list"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null], InferData<TAuthClient["organization"]["list"]>, BetterFetchError>;
+};
+export declare const ensureListOrganizations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListOrganizationsParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["list"]>>;
+export declare const prefetchListOrganizations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListOrganizationsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListOrganizations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListOrganizationsParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["list"]>>;
+export type UseListOrganizationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListOrganizationsOptions<TAuthClient> & ListOrganizationsParams<TAuthClient>;
+export declare function useListOrganizations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationsOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["organization"]["list"]>>, BetterFetchError>;

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

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

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

@@ -0,0 +1,29 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client";
+export type ListUserInvitationsData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = InferData<TAuthClient["organization"]["listUserInvitations"]>;
+export type ListUserInvitationsParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["listUserInvitations"]>[0];
+export type ListUserInvitationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof listUserInvitationsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listUserInvitationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["organization"]["listUserInvitations"]>, BetterFetchError, InferData<TAuthClient["organization"]["listUserInvitations"]>, readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+    email?: string | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["organization"]["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]: InferData<TAuthClient["organization"]["listUserInvitations"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+        email?: string | undefined;
+    } | null], InferData<TAuthClient["organization"]["listUserInvitations"]>, BetterFetchError>;
+};
+export declare const ensureListUserInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["listUserInvitations"]>>;
+export declare const prefetchListUserInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListUserInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>) => Promise<InferData<TAuthClient["organization"]["listUserInvitations"]>>;
+export type UseListUserInvitationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListUserInvitationsOptions<TAuthClient> & ListUserInvitationsParams<TAuthClient>;
+export declare function useListUserInvitations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListUserInvitationsOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["organization"]["listUserInvitations"]>>, BetterFetchError>;

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

@@ -0,0 +1,31 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
+import { useSession } from "../auth/session-query";
+export function listUserInvitationsOptions(authClient, userId, params) {
+    const queryKey = organizationQueryKeys.userInvitations.list(userId, params?.query);
+    const options = queryOptions({
+        queryKey,
+        queryFn: ({ signal }) => authClient.organization.listUserInvitations({
+            ...params,
+            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        })
+    });
+    return options;
+}
+export const ensureListUserInvitations = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listUserInvitationsOptions(authClient, userId, params));
+export const prefetchListUserInvitations = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listUserInvitationsOptions(authClient, userId, params));
+export const fetchListUserInvitations = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listUserInvitationsOptions(authClient, userId, params));
+export function useListUserInvitations(authClient, options = {}, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { query, fetchOptions, ...queryOptions } = options;
+    const baseOptions = listUserInvitationsOptions(authClient, userId, {
+        query,
+        fetchOptions
+    });
+    return useQuery({
+        ...queryOptions,
+        ...baseOptions,
+        queryFn: userId ? baseOptions.queryFn : skipToken
+    }, queryClient);
+}

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

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { BetterFetchError } from 'better-auth/react';
-import { InferData, PasskeyAuthClient } from '../../lib/auth-client';
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { InferData, PasskeyAuthClient } from "../../lib/auth-client";
 export type ListPasskeysData<TAuthClient extends PasskeyAuthClient> = InferData<TAuthClient["passkey"]["listUserPasskeys"]>;
 export type ListPasskeysParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["passkey"]["listUserPasskeys"]>[0];
 export type ListPasskey<TAuthClient extends PasskeyAuthClient = PasskeyAuthClient> = NonNullable<ListPasskeysData<TAuthClient>>[number];
@@ -12,15 +12,15 @@ export type ListPasskeysOptions<TAuthClient extends PasskeyAuthClient> = Omit<Re
  * @param userId - The current signed-in user's ID. Used for cache partitioning.
  * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
  */
-export declare function listPasskeysOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListPasskeysParams<TAuthClient>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<InferData<TAuthClient["passkey"]["listUserPasskeys"]>, BetterFetchError, InferData<TAuthClient["passkey"]["listUserPasskeys"]>, readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<InferData<TAuthClient["passkey"]["listUserPasskeys"]>, readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null], never> | undefined;
+export declare function listPasskeysOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListPasskeysParams<TAuthClient>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<InferData<TAuthClient["passkey"]["listUserPasskeys"]>, BetterFetchError, InferData<TAuthClient["passkey"]["listUserPasskeys"]>, readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<InferData<TAuthClient["passkey"]["listUserPasskeys"]>, 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]: InferData<TAuthClient["passkey"]["listUserPasskeys"]>;
         [dataTagErrorSymbol]: BetterFetchError;
     };
 }) & {
-    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listPasskeys", Record<string, any> | null], InferData<TAuthClient["passkey"]["listUserPasskeys"]>, BetterFetchError>;
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null], InferData<TAuthClient["passkey"]["listUserPasskeys"]>, BetterFetchError>;
 };
 /**
  * Get the current user's passkeys from the query cache, calling
@@ -71,4 +71,4 @@ export type UseListPasskeysOptions<TAuthClient extends PasskeyAuthClient> = List
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useListPasskeys<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: UseListPasskeysOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["passkey"]["listUserPasskeys"]>>, BetterFetchError>;
+export declare function useListPasskeys<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: UseListPasskeysOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseQueryResult<NoInfer<InferData<TAuthClient["passkey"]["listUserPasskeys"]>>, BetterFetchError>;