@better-auth-ui/react 1.6.8 → 1.6.9

package/dist/mutations/organization/leave-organization-mutation.d.ts

@@ -0,0 +1,65 @@
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+export type LeaveOrganizationParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["leave"]>[0];
+export type LeaveOrganizationOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof leaveOrganizationOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
+export declare function leaveOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<Omit<{
+    id: string;
+    organizationId: string;
+    role: "member" | "admin" | "owner";
+    createdAt: Date;
+    userId: string;
+    user: {
+        id: string;
+        email: string;
+        name: string;
+        image?: string | undefined;
+    };
+} & {
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    };
+}, "user"> & {
+    user: {
+        id: string;
+        name: string;
+        email: string;
+        image: string | undefined;
+    };
+}, BetterFetchError, LeaveOrganizationParams<TAuthClient>, unknown>, "mutationKey">;
+export declare function useLeaveOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: LeaveOrganizationOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<Omit<{
+    id: string;
+    organizationId: string;
+    role: "member" | "admin" | "owner";
+    createdAt: Date;
+    userId: string;
+    user: {
+        id: string;
+        email: string;
+        name: string;
+        image?: string | undefined;
+    };
+} & {
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    };
+}, "user"> & {
+    user: {
+        id: string;
+        name: string;
+        email: string;
+        image: string | undefined;
+    };
+}, BetterFetchError, LeaveOrganizationParams<TAuthClient>, unknown>;

package/dist/mutations/organization/leave-organization-mutation.js

@@ -0,0 +1,32 @@
+import { organizationMutationKeys, organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+export function leaveOrganizationOptions(authClient) {
+    const mutationKey = organizationMutationKeys.leave;
+    const mutationFn = (params) => authClient.organization.leave({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useLeaveOrganization(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...leaveOrganizationOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [
+                organizationQueryKeys.members.all(userId),
+                organizationQueryKeys.fullDetails(userId)
+            ],
+            invalidates: [
+                organizationQueryKeys.lists(userId),
+                organizationQueryKeys.activeOrganizations(userId)
+            ]
+        }
+    }, queryClient);
+}

package/dist/mutations/organization/reject-invitation-mutation.d.ts

@@ -0,0 +1,31 @@
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+export type RejectInvitationParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["rejectInvitation"]>[0];
+export type RejectInvitationOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof rejectInvitationOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
+export declare function rejectInvitationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
+    invitation: {
+        id: string;
+        organizationId: string;
+        email: string;
+        role: "admin" | "member" | "owner";
+        status: import("better-auth/client").InvitationStatus;
+        inviterId: string;
+        expiresAt: Date;
+        createdAt: Date;
+    } | null;
+    member: null;
+}, BetterFetchError, RejectInvitationParams<TAuthClient>, unknown>, "mutationKey">;
+export declare function useRejectInvitation<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: RejectInvitationOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
+    invitation: {
+        id: string;
+        organizationId: string;
+        email: string;
+        role: "admin" | "member" | "owner";
+        status: import("better-auth/client").InvitationStatus;
+        inviterId: string;
+        expiresAt: Date;
+        createdAt: Date;
+    } | null;
+    member: null;
+}, BetterFetchError, RejectInvitationParams<TAuthClient>, unknown>;

package/dist/mutations/organization/reject-invitation-mutation.js

@@ -0,0 +1,25 @@
+import { organizationMutationKeys, organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+export function rejectInvitationOptions(authClient) {
+    const mutationKey = organizationMutationKeys.rejectInvitation;
+    const mutationFn = (params) => authClient.organization.rejectInvitation({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useRejectInvitation(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...rejectInvitationOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [organizationQueryKeys.userInvitations.all(userId)]
+        }
+    }, queryClient);
+}

package/dist/mutations/organization/remove-member-mutation.d.ts

@@ -0,0 +1,35 @@
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+export type RemoveMemberParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["removeMember"]>[0];
+export type RemoveMemberOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof removeMemberOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
+export declare function removeMemberOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
+    member: {
+        id: string;
+        organizationId: string;
+        role: "member" | "admin" | "owner";
+        createdAt: Date;
+        userId: string;
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | undefined;
+        };
+    };
+}, BetterFetchError, RemoveMemberParams<TAuthClient>, unknown>, "mutationKey">;
+export declare function useRemoveMember<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: RemoveMemberOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
+    member: {
+        id: string;
+        organizationId: string;
+        role: "member" | "admin" | "owner";
+        createdAt: Date;
+        userId: string;
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | undefined;
+        };
+    };
+}, BetterFetchError, RemoveMemberParams<TAuthClient>, unknown>;

package/dist/mutations/organization/remove-member-mutation.js

@@ -0,0 +1,29 @@
+import { organizationMutationKeys, organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+export function removeMemberOptions(authClient) {
+    const mutationKey = organizationMutationKeys.removeMember;
+    const mutationFn = (params) => authClient.organization.removeMember({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useRemoveMember(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...removeMemberOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [
+                organizationQueryKeys.members.all(userId),
+                organizationQueryKeys.fullDetails(userId)
+            ],
+            invalidates: [organizationQueryKeys.lists(userId)]
+        }
+    }, queryClient);
+}

package/dist/mutations/organization/set-active-organization-mutation.d.ts

@@ -0,0 +1,71 @@
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+export type SetActiveOrganizationParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["setActive"]>[0];
+export type SetActiveOrganizationOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof setActiveOrganizationOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
+export declare function setActiveOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
+    members: {
+        id: string;
+        organizationId: string;
+        role: "member" | "admin" | "owner";
+        createdAt: Date;
+        userId: string;
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | undefined;
+        };
+    }[];
+    invitations: {
+        id: string;
+        organizationId: string;
+        email: string;
+        role: "member" | "admin" | "owner";
+        status: import("better-auth/client").InvitationStatus;
+        inviterId: string;
+        expiresAt: Date;
+        createdAt: Date;
+    }[];
+} & {
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: Date;
+    logo?: string | null | undefined | undefined;
+    metadata?: any;
+}, BetterFetchError, SetActiveOrganizationParams<TAuthClient>, unknown>, "mutationKey">;
+export declare function useSetActiveOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: SetActiveOrganizationOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
+    members: {
+        id: string;
+        organizationId: string;
+        role: "member" | "admin" | "owner";
+        createdAt: Date;
+        userId: string;
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | undefined;
+        };
+    }[];
+    invitations: {
+        id: string;
+        organizationId: string;
+        email: string;
+        role: "member" | "admin" | "owner";
+        status: import("better-auth/client").InvitationStatus;
+        inviterId: string;
+        expiresAt: Date;
+        createdAt: Date;
+    }[];
+} & {
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: Date;
+    logo?: string | null | undefined | undefined;
+    metadata?: any;
+}, BetterFetchError, SetActiveOrganizationParams<TAuthClient>, {
+    previousOrganizations: [readonly unknown[], unknown][];
+}>;

package/dist/mutations/organization/set-active-organization-mutation.js

@@ -0,0 +1,72 @@
+import { organizationMutationKeys, organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+import { useListOrganizations } from "../../queries/organization";
+export function setActiveOrganizationOptions(authClient) {
+    const mutationKey = organizationMutationKeys.setActive;
+    const mutationFn = (params) => authClient.organization.setActive({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useSetActiveOrganization(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { data: organizations } = useListOrganizations(authClient, undefined, queryClient);
+    return useMutation({
+        ...setActiveOrganizationOptions(authClient),
+        ...options,
+        onMutate: async (variables, context) => {
+            // Cancel any outgoing refetches across every slug-partitioned
+            // active-organization cache entry so they don't overwrite our
+            // optimistic update.
+            await context.client.cancelQueries({
+                queryKey: organizationQueryKeys.activeOrganizations(userId)
+            });
+            // Snapshot every slug-partitioned variant so the rollback hits
+            // whichever cache entry the UI is actually subscribed to (the
+            // entry's key is `[..., 'active', { organizationSlug }]` when the
+            // plugin's slug option is set, and `[..., 'active', null]`
+            // otherwise).
+            const previousOrganizations = context.client.getQueriesData({
+                queryKey: organizationQueryKeys.activeOrganizations(userId)
+            });
+            // Optimistically update to the new value
+            if (variables?.organizationId === null) {
+                context.client.setQueriesData({ queryKey: organizationQueryKeys.activeOrganizations(userId) }, null);
+                return { previousOrganizations };
+            }
+            const newOrganization = organizations?.find((organization) => (variables?.organizationId !== undefined &&
+                organization.id === variables.organizationId) ||
+                (variables?.organizationSlug !== undefined &&
+                    organization.slug === variables.organizationSlug));
+            if (newOrganization) {
+                context.client.setQueriesData({ queryKey: organizationQueryKeys.activeOrganizations(userId) }, newOrganization);
+            }
+            return { previousOrganizations };
+        },
+        // If the mutation fails,
+        // use the result returned from onMutate to roll back
+        onError: (error, variables, onMutateResult, context) => {
+            const previousOrganizations = onMutateResult?.previousOrganizations;
+            if (previousOrganizations?.length && error.error) {
+                for (const [queryKey, data] of previousOrganizations) {
+                    context.client.setQueryData(queryKey, data);
+                }
+            }
+            return options?.onError?.(error, variables, onMutateResult, context);
+        },
+        // Always refetch after error or success — invalidate every
+        // slug-partitioned variant via the broader prefix.
+        onSettled: async (data, error, variables, onMutateResult, context) => {
+            await context.client.invalidateQueries({
+                queryKey: organizationQueryKeys.activeOrganizations(userId)
+            });
+            return options?.onSettled?.(data, error, variables, onMutateResult, context);
+        }
+    }, queryClient);
+}

package/dist/mutations/organization/update-member-role-mutation.d.ts

@@ -0,0 +1,31 @@
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+export type UpdateMemberRoleParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["updateMemberRole"]>[0];
+export type UpdateMemberRoleOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof updateMemberRoleOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
+export declare function updateMemberRoleOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
+    id: string;
+    organizationId: string;
+    role: "admin" | "member" | "owner";
+    createdAt: Date;
+    userId: string;
+    user: {
+        id: string;
+        email: string;
+        name: string;
+        image?: string | undefined;
+    };
+}, BetterFetchError, UpdateMemberRoleParams<TAuthClient>, unknown>, "mutationKey">;
+export declare function useUpdateMemberRole<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UpdateMemberRoleOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    organizationId: string;
+    role: "admin" | "member" | "owner";
+    createdAt: Date;
+    userId: string;
+    user: {
+        id: string;
+        email: string;
+        name: string;
+        image?: string | undefined;
+    };
+}, BetterFetchError, UpdateMemberRoleParams<TAuthClient>, unknown>;

package/dist/mutations/organization/update-member-role-mutation.js

@@ -0,0 +1,36 @@
+import { organizationMutationKeys, organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+import { useActiveOrganization } from "../../queries/organization";
+export function updateMemberRoleOptions(authClient) {
+    const mutationKey = organizationMutationKeys.updateMemberRole;
+    const mutationFn = (params) => authClient.organization.updateMemberRole({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useUpdateMemberRole(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { data: activeOrganization } = useActiveOrganization(authClient, undefined, queryClient);
+    return useMutation({
+        ...updateMemberRoleOptions(authClient),
+        ...options,
+        mutationFn: (params) => authClient.organization.updateMemberRole({
+            ...params,
+            organizationId: params?.organizationId ?? activeOrganization?.id,
+            fetchOptions: { ...params?.fetchOptions, throw: true }
+        }),
+        meta: {
+            awaits: [
+                organizationQueryKeys.members.all(userId),
+                organizationQueryKeys.fullDetails(userId)
+            ],
+            invalidates: [organizationQueryKeys.permissions.all(userId)]
+        }
+    }, queryClient);
+}

package/dist/mutations/organization/update-organization-mutation.d.ts

@@ -0,0 +1,21 @@
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+export type UpdateOrganizationParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["update"]>[0];
+export type UpdateOrganizationOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof updateOrganizationOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
+export declare function updateOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: Date;
+    logo?: string | null | undefined | undefined;
+    metadata?: any;
+}, BetterFetchError, UpdateOrganizationParams<TAuthClient>, unknown>, "mutationKey">;
+export declare function useUpdateOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UpdateOrganizationOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: Date;
+    logo?: string | null | undefined | undefined;
+    metadata?: any;
+}, BetterFetchError, UpdateOrganizationParams<TAuthClient>, unknown>;

package/dist/mutations/organization/update-organization-mutation.js

@@ -0,0 +1,36 @@
+import { organizationMutationKeys, organizationQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+import { useActiveOrganization } from "../../queries/organization";
+export function updateOrganizationOptions(authClient) {
+    const mutationKey = organizationMutationKeys.update;
+    const mutationFn = (params) => authClient.organization.update({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useUpdateOrganization(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { data: activeOrganization } = useActiveOrganization(authClient, undefined, queryClient);
+    return useMutation({
+        ...updateOrganizationOptions(authClient),
+        ...options,
+        mutationFn: (params) => authClient.organization.update({
+            ...params,
+            organizationId: params?.organizationId ?? activeOrganization?.id,
+            fetchOptions: { ...params?.fetchOptions, throw: true }
+        }),
+        meta: {
+            awaits: [
+                organizationQueryKeys.lists(userId),
+                organizationQueryKeys.fullDetails(userId),
+                organizationQueryKeys.activeOrganizations(userId)
+            ]
+        }
+    }, queryClient);
+}

package/dist/mutations/passkey/add-passkey-mutation.d.ts

@@ -1,13 +1,14 @@
-import { BetterFetchError } from 'better-auth/react';
-import { PasskeyAuthClient } from '../../lib/auth-client';
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { PasskeyAuthClient } from "../../lib/auth-client";
 export type AddPasskeyParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["passkey"]["addPasskey"]>[0];
-export type AddPasskeyOptions<TAuthClient extends PasskeyAuthClient> = Omit<ReturnType<typeof addPasskeyOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+export type AddPasskeyOptions<TAuthClient extends PasskeyAuthClient> = Omit<ReturnType<typeof addPasskeyOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * Mutation options factory for registering a new passkey.
  *
  * @param authClient - The Better Auth client with the passkey plugin.
  */
-export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
     data: null;
     error: {
         message?: string | undefined;
@@ -15,14 +16,14 @@ export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>
         statusText: string;
     };
 } | {
-    data: import('@better-auth/passkey').Passkey;
+    data: import("@better-auth/passkey").Passkey;
     error: null;
 } | {
     webauthn: {
-        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
-        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+        response: import("@better-auth/passkey/client").RegistrationResponseJSON;
+        clientExtensionResults: import("@better-auth/passkey/client").AuthenticationExtensionsClientOutputs;
     };
-    data: import('@better-auth/passkey').Passkey;
+    data: import("@better-auth/passkey").Passkey;
     error: null;
 } | {
     data: null;
@@ -36,14 +37,13 @@ export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>
 /**
  * Create a mutation for registering a new passkey.
  *
- * Wraps `authClient.passkey.addPasskey`, refetches the user's passkey list
- * on success, and forwards React Query mutation options such as
- * `onSuccess`, `onError`, and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the user's
+ * passkey list (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client with the passkey plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
-export declare function useAddPasskey<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: AddPasskeyOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+export declare function useAddPasskey<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: AddPasskeyOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
     data: null;
     error: {
         message?: string | undefined;
@@ -51,14 +51,14 @@ export declare function useAddPasskey<TAuthClient extends PasskeyAuthClient>(aut
         statusText: string;
     };
 } | {
-    data: import('@better-auth/passkey').Passkey;
+    data: import("@better-auth/passkey").Passkey;
     error: null;
 } | {
     webauthn: {
-        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
-        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+        response: import("@better-auth/passkey/client").RegistrationResponseJSON;
+        clientExtensionResults: import("@better-auth/passkey/client").AuthenticationExtensionsClientOutputs;
     };
-    data: import('@better-auth/passkey').Passkey;
+    data: import("@better-auth/passkey").Passkey;
     error: null;
 } | {
     data: null;

package/dist/mutations/passkey/add-passkey-mutation.js

@@ -1,29 +1,40 @@
-import { useListPasskeys as e } from "../../queries/passkey/list-passkeys-query.js";
-import { mutationOptions as t, useMutation as n } from "@tanstack/react-query";
-import { passkeyMutationKeys as r } from "@better-auth-ui/core/plugins";
-//#region src/mutations/passkey/add-passkey-mutation.ts
-function i(e) {
-	let n = r.addPasskey;
-	return t({
-		mutationKey: n,
-		mutationFn: (t) => e.passkey.addPasskey({
-			...t ?? {},
-			fetchOptions: {
-				...t?.fetchOptions,
-				throw: !0
-			}
-		})
-	});
+import { passkeyMutationKeys, passkeyQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+/**
+ * Mutation options factory for registering a new passkey.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ */
+export function addPasskeyOptions(authClient) {
+    const mutationKey = passkeyMutationKeys.addPasskey;
+    // biome-ignore lint/suspicious/noConfusingVoidType: void allows no-arg mutate
+    const mutationFn = (params) => authClient.passkey.addPasskey({
+        ...(params ?? {}),
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-function a(t, r) {
-	let { refetch: a } = e(t, { refetchOnMount: !1 });
-	return n({
-		...i(t),
-		...r,
-		onSuccess: async (...e) => {
-			await a(), await r?.onSuccess?.(...e);
-		}
-	});
+/**
+ * Create a mutation for registering a new passkey.
+ *
+ * On success, `MutationInvalidator` awaits invalidation of the user's
+ * passkey list (see `meta.awaits`).
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useAddPasskey(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...addPasskeyOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [passkeyQueryKeys.lists(userId)]
+        }
+    }, queryClient);
 }
-//#endregion
-export { i as addPasskeyOptions, a as useAddPasskey };