@better-auth-ui/react 1.6.8 → 1.6.10

package/dist/queries/organization/full-organization-query.d.ts

@@ -0,0 +1,37 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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/has-permission-query.d.ts

@@ -0,0 +1,21 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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/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/list-invitations-query.d.ts

@@ -0,0 +1,29 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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-members-query.d.ts

@@ -0,0 +1,61 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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-organizations-query.d.ts

@@ -0,0 +1,22 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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-user-invitations-query.d.ts

@@ -0,0 +1,29 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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/passkey/list-passkeys-query.d.ts

@@ -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>;

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

@@ -82,4 +82,4 @@ export type UseAccountInfoOptions<TAuthClient extends AuthClient> = AccountInfoO
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useAccountInfo<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseAccountInfoOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["accountInfo"]>>, BetterFetchError>;
+export declare function useAccountInfo<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseAccountInfoOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<NoInfer<InferData<TAuthClient["accountInfo"]>>, BetterFetchError>;

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

@@ -73,4 +73,4 @@ export type UseListAccountsOptions<TAuthClient extends AuthClient> = ListAccount
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useListAccounts<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListAccountsOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["listAccounts"]>>, BetterFetchError>;
+export declare function useListAccounts<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListAccountsOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<NoInfer<InferData<TAuthClient["listAccounts"]>>, BetterFetchError>;

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

@@ -71,4 +71,4 @@ export type UseListSessionsOptions<TAuthClient extends AuthClient> = ListSession
  * @param queryClient - Optional custom `QueryClient`. Defaults to the client
  *   from the nearest `QueryClientProvider`.
  */
-export declare function useListSessions<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListSessionsOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<import('@tanstack/react-query').NoInfer<InferData<TAuthClient["listSessions"]>>, BetterFetchError>;
+export declare function useListSessions<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListSessionsOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<NoInfer<InferData<TAuthClient["listSessions"]>>, BetterFetchError>;

package/dist/server/queries/api-key/list-api-keys-query.d.ts

@@ -0,0 +1,83 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { ApiKeyAuthServer } from '../../../lib/auth-server';
+export type ListApiKeysData<TAuth extends ApiKeyAuthServer = ApiKeyAuthServer> = Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>;
+export type ListedApiKey<TAuth extends ApiKeyAuthServer = ApiKeyAuthServer> = NonNullable<ListApiKeysData<TAuth>>["apiKeys"][number];
+export type ListApiKeysParams<TAuth extends ApiKeyAuthServer = ApiKeyAuthServer> = Parameters<TAuth["api"]["listApiKeys"]>[0];
+/**
+ * Query options factory for the current user's API keys on the server.
+ *
+ * Uses the same query key as the client-side `listApiKeysOptions` so that data
+ * fetched during SSR hydrates seamlessly into the client's React Query cache.
+ *
+ * @param auth - The Better Auth server instance with the API key plugin.
+ * @param userId - The signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listApiKeys`.
+ */
+export declare function listApiKeysOptions<TAuth extends ApiKeyAuthServer>(auth: TAuth, userId: string, params: ListApiKeysParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>, readonly ["auth", "user", string | undefined, "apiKey", "list", {
+    configId?: string | undefined;
+    organizationId?: string | undefined;
+    limit?: unknown;
+    offset?: unknown;
+    sortBy?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>, readonly ["auth", "user", string | undefined, "apiKey", "list", {
+        configId?: string | undefined;
+        organizationId?: string | undefined;
+        limit?: unknown;
+        offset?: unknown;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "apiKey", "list", {
+        configId?: string | undefined;
+        organizationId?: string | undefined;
+        limit?: unknown;
+        offset?: unknown;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+    } | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "apiKey", "list", {
+        configId?: string | undefined;
+        organizationId?: string | undefined;
+        limit?: unknown;
+        offset?: unknown;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+    } | null], Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>, APIError>;
+};
+/**
+ * Get the current user's API keys from the query cache, calling
+ * `fetchListApiKeys` under the hood if no cached entry exists.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the API key plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listApiKeys`.
+ */
+export declare const ensureListApiKeys: <TAuth extends ApiKeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListApiKeysParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>>;
+/**
+ * Prefetch the current user's API keys into the query cache.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the API key plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listApiKeys`.
+ */
+export declare const prefetchListApiKeys: <TAuth extends ApiKeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListApiKeysParams<TAuth>) => Promise<void>;
+/**
+ * Fetch and cache the current user's API keys, resolving with the data or
+ * throwing on error.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the API key plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listApiKeys`.
+ */
+export declare const fetchListApiKeys: <TAuth extends ApiKeyAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListApiKeysParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listApiKeys"]>>>;

package/dist/server/queries/multi-session/list-device-sessions-query.d.ts

@@ -12,15 +12,15 @@ export type ListDeviceSessionsParams<TAuth extends MultiSessionAuthServer> = Par
  *   the key matches the client-side `listDeviceSessionsOptions` for SSR hydration.
  * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
  */
-export declare function listDeviceSessionsOptions<TAuth extends MultiSessionAuthServer>(auth: TAuth, userId: string, params: ListDeviceSessionsParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null], never> | undefined;
+export declare function listDeviceSessionsOptions<TAuth extends MultiSessionAuthServer>(auth: TAuth, userId: string, params: ListDeviceSessionsParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null], never> | undefined;
 } & {
-    queryKey: readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null] & {
+    queryKey: readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null] & {
         [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>;
         [dataTagErrorSymbol]: APIError;
     };
 }) & {
-    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError>;
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError>;
 };
 /**
  * Get the current user's device sessions from the query cache, calling

package/dist/server/queries/organization/active-organization-query.d.ts

@@ -0,0 +1,61 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { OrganizationAuthServer } from '../../../lib/auth-server';
+import { FullOrganizationParams } from './full-organization-query';
+import { ListOrganization } from './list-organizations-query';
+/**
+ * Cache shape for the active organization. Intentionally narrowed to
+ * {@link ListOrganization} (basic fields only) so the cache stays
+ * compatible with `setActive`'s optimistic update, which can only produce
+ * list-shaped data. Use {@link FullOrganizationData} (via
+ * `fullOrganizationOptions`) when you need members / invitations.
+ */
+export type ActiveOrganizationData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = ListOrganization<TAuth>;
+/**
+ * Same shape as {@link FullOrganizationParams} so server-side prefetches
+ * can target a specific organization (e.g. by `query.organizationSlug` for
+ * slug-driven routes) and produce a cache key that matches the client's
+ * `useActiveOrganization({ query: { organizationSlug } })` on hydration.
+ */
+export type ActiveOrganizationParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = FullOrganizationParams<TAuth>;
+/**
+ * Query options factory for the active organization. Shares its cache key
+ * with the client-side `activeOrganizationOptions` (including any
+ * `params.query` partition such as `{ organizationSlug }`) so SSR-prefetched
+ * data hydrates without a refetch — even on slug-prefixed routes.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `activeOrganizationOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.getFullOrganization`. Pass
+ *   `{ query: { organizationSlug } }` for slug-driven prefetches.
+ */
+export declare function activeOrganizationOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: ActiveOrganizationParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<ActiveOrganizationData<TAuth>, APIError, ActiveOrganizationData<TAuth>, readonly ["auth", "user", string | undefined, "organization", "active", {
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+    membersLimit?: string | number | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<ActiveOrganizationData<TAuth>, readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: ActiveOrganizationData<TAuth>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], ActiveOrganizationData<TAuth>, APIError>;
+};
+export declare const ensureActiveOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ActiveOrganizationParams<TAuth>) => Promise<ActiveOrganizationData<TAuth>>;
+export declare const prefetchActiveOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ActiveOrganizationParams<TAuth>) => Promise<void>;
+export declare const fetchActiveOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ActiveOrganizationParams<TAuth>) => Promise<ActiveOrganizationData<TAuth>>;

package/dist/server/queries/organization/full-organization-query.d.ts

@@ -0,0 +1,42 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { OrganizationAuthServer } from '../../../lib/auth-server';
+export type FullOrganizationData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>;
+export type FullOrganizationParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Parameters<TAuth["api"]["getFullOrganization"]>[0];
+/**
+ * Query options factory for full organization details (members, invitations, etc.).
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `fullOrganizationOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.getFullOrganization`.
+ */
+export declare function fullOrganizationOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: FullOrganizationParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>, APIError, Awaited<ReturnType<TAuth["api"]["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<Awaited<ReturnType<TAuth["api"]["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]: Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>, APIError>;
+};
+export declare const ensureFullOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: FullOrganizationParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>>;
+export declare const prefetchFullOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: FullOrganizationParams<TAuth>) => Promise<void>;
+export declare const fetchFullOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: FullOrganizationParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>>;

package/dist/server/queries/organization/has-permission-query.d.ts

@@ -0,0 +1,66 @@
+import { DataTag, QueryClient } from '@tanstack/react-query';
+import { APIError } from 'better-auth';
+import { OrganizationAuthServer } from '../../../lib/auth-server';
+export type HasPermissionData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Awaited<ReturnType<TAuth["api"]["hasPermission"]>>;
+export type HasPermissionParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Parameters<TAuth["api"]["hasPermission"]>[0];
+/**
+ * Query options factory for organization permission checks.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `hasPermissionOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.hasPermission`.
+ */
+export declare function hasPermissionOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: HasPermissionParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["hasPermission"]>>, APIError, Awaited<ReturnType<TAuth["api"]["hasPermission"]>>, readonly ["auth", "user", string | undefined, "organization", "permissions", "has", NonNullable<{
+    permissions: {
+        readonly organization?: ("update" | "delete")[] | undefined;
+        readonly member?: ("update" | "delete" | "create")[] | undefined;
+        readonly invitation?: ("create" | "cancel")[] | undefined;
+        readonly team?: ("update" | "delete" | "create")[] | undefined;
+        readonly ac?: ("update" | "delete" | "create" | "read")[] | undefined;
+    };
+} & {
+    organizationId?: string | undefined;
+}> | null]>, "queryFn"> & {
+    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["hasPermission"]>>, readonly ["auth", "user", string | undefined, "organization", "permissions", "has", NonNullable<{
+        permissions: {
+            readonly organization?: ("update" | "delete")[] | undefined;
+            readonly member?: ("update" | "delete" | "create")[] | undefined;
+            readonly invitation?: ("create" | "cancel")[] | undefined;
+            readonly team?: ("update" | "delete" | "create")[] | undefined;
+            readonly ac?: ("update" | "delete" | "create" | "read")[] | undefined;
+        };
+    } & {
+        organizationId?: string | undefined;
+    }> | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "permissions", "has", NonNullable<{
+        permissions: {
+            readonly organization?: ("update" | "delete")[] | undefined;
+            readonly member?: ("update" | "delete" | "create")[] | undefined;
+            readonly invitation?: ("create" | "cancel")[] | undefined;
+            readonly team?: ("update" | "delete" | "create")[] | undefined;
+            readonly ac?: ("update" | "delete" | "create" | "read")[] | undefined;
+        };
+    } & {
+        organizationId?: string | undefined;
+    }> | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["hasPermission"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "permissions", "has", NonNullable<{
+        permissions: {
+            readonly organization?: ("update" | "delete")[] | undefined;
+            readonly member?: ("update" | "delete" | "create")[] | undefined;
+            readonly invitation?: ("create" | "cancel")[] | undefined;
+            readonly team?: ("update" | "delete" | "create")[] | undefined;
+            readonly ac?: ("update" | "delete" | "create" | "read")[] | undefined;
+        };
+    } & {
+        organizationId?: string | undefined;
+    }> | null], Awaited<ReturnType<TAuth["api"]["hasPermission"]>>, APIError>;
+};
+export declare const ensureHasPermission: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: HasPermissionParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["hasPermission"]>>>;
+export declare const prefetchHasPermission: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: HasPermissionParams<TAuth>) => Promise<void>;
+export declare const fetchHasPermission: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: HasPermissionParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["hasPermission"]>>>;