@better-auth-ui/react 1.6.8 → 1.6.9

package/dist/mutations/multi-session/revoke-multi-session-mutation.d.ts

@@ -1,25 +1,25 @@
-import { BetterFetchError } from 'better-auth/react';
-import { MultiSessionAuthClient } from '../../lib/auth-client';
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { MultiSessionAuthClient } from "../../lib/auth-client";
 export type RevokeMultiSessionParams<TAuthClient extends MultiSessionAuthClient> = Parameters<TAuthClient["multiSession"]["revoke"]>[0];
-export type RevokeMultiSessionOptions<TAuthClient extends MultiSessionAuthClient> = Omit<ReturnType<typeof revokeMultiSessionOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+export type RevokeMultiSessionOptions<TAuthClient extends MultiSessionAuthClient> = Omit<ReturnType<typeof revokeMultiSessionOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * Mutation options factory for revoking a device session in multi-session mode.
  *
  * @param authClient - The Better Auth client with the multi-session plugin.
  */
-export declare function revokeMultiSessionOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+export declare function revokeMultiSessionOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
     status: boolean;
 }, BetterFetchError, RevokeMultiSessionParams<TAuthClient>, unknown>, "mutationKey">;
 /**
  * Create a mutation for revoking a device session in multi-session mode.
  *
- * Wraps `authClient.multiSession.revoke`, refetches the device sessions list
- * on success, and forwards React Query mutation options such as `onSuccess`,
- * `onError`, and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the device
+ * sessions list (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client with the multi-session plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
-export declare function useRevokeMultiSession<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: RevokeMultiSessionOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+export declare function useRevokeMultiSession<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: RevokeMultiSessionOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
     status: boolean;
 }, BetterFetchError, RevokeMultiSessionParams<TAuthClient>, unknown>;

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

@@ -1,29 +1,39 @@
-import { useListDeviceSessions as e } from "../../queries/multi-session/list-device-sessions-query.js";
-import { authMutationKeys as t } from "@better-auth-ui/core";
-import { mutationOptions as n, useMutation as r } from "@tanstack/react-query";
-//#region src/mutations/multi-session/revoke-multi-session-mutation.ts
-function i(e) {
-	let r = t.multiSession.revoke;
-	return n({
-		mutationKey: r,
-		mutationFn: (t) => e.multiSession.revoke({
-			...t,
-			fetchOptions: {
-				...t?.fetchOptions,
-				throw: !0
-			}
-		})
-	});
+import { multiSessionMutationKeys, multiSessionQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+/**
+ * Mutation options factory for revoking a device session in multi-session mode.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ */
+export function revokeMultiSessionOptions(authClient) {
+    const mutationKey = multiSessionMutationKeys.revoke;
+    const mutationFn = (params) => authClient.multiSession.revoke({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-function a(t, n) {
-	let { refetch: a } = e(t, { refetchOnMount: !1 });
-	return r({
-		...i(t),
-		...n,
-		onSuccess: async (...e) => {
-			await a(), await n?.onSuccess?.(...e);
-		}
-	});
+/**
+ * Create a mutation for revoking a device session in multi-session mode.
+ *
+ * On success, `MutationInvalidator` awaits invalidation of the device
+ * sessions list (see `meta.awaits`).
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useRevokeMultiSession(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...revokeMultiSessionOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [multiSessionQueryKeys.lists(userId)]
+        }
+    }, queryClient);
 }
-//#endregion
-export { i as revokeMultiSessionOptions, a as useRevokeMultiSession };

package/dist/mutations/multi-session/set-active-session-mutation.d.ts

@@ -1,13 +1,14 @@
-import { BetterFetchError } from 'better-auth/react';
-import { MultiSessionAuthClient } from '../../lib/auth-client';
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { MultiSessionAuthClient } from "../../lib/auth-client";
 export type SetActiveSessionParams<TAuthClient extends MultiSessionAuthClient> = Parameters<TAuthClient["multiSession"]["setActive"]>[0];
-export type SetActiveSessionOptions<TAuthClient extends MultiSessionAuthClient> = Omit<ReturnType<typeof setActiveSessionOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+export type SetActiveSessionOptions<TAuthClient extends MultiSessionAuthClient> = Omit<ReturnType<typeof setActiveSessionOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * Mutation options factory for switching the active device session.
  *
  * @param authClient - The Better Auth client with the multi-session plugin.
  */
-export declare function setActiveSessionOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient): import('@tanstack/react-query').WithRequired<import('@tanstack/react-query').UseMutationOptions<{
+export declare function setActiveSessionOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
     session: {
         id: string;
         createdAt: Date;
@@ -31,15 +32,13 @@ export declare function setActiveSessionOptions<TAuthClient extends MultiSession
 /**
  * Create a mutation for switching the active device session.
  *
- * Wraps `authClient.multiSession.setActive`, optimistically swaps the cached
- * session to the matching device session, refetches both the session and
- * device-session queries, and forwards React Query mutation options such as
- * `onSuccess`, `onError`, and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * and device sessions queries (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client with the multi-session plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
-export declare function useSetActiveSession<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: SetActiveSessionOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+export declare function useSetActiveSession<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: SetActiveSessionOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
     session: {
         id: string;
         createdAt: Date;

package/dist/mutations/multi-session/set-active-session-mutation.js

@@ -1,31 +1,40 @@
-import { sessionOptions as e, useSession as t } from "../../queries/auth/session-query.js";
-import { useListDeviceSessions as n } from "../../queries/multi-session/list-device-sessions-query.js";
-import { authMutationKeys as r } from "@better-auth-ui/core";
-import { mutationOptions as i, useMutation as a, useQueryClient as o } from "@tanstack/react-query";
-//#region src/mutations/multi-session/set-active-session-mutation.ts
-function s(e) {
-	let t = r.multiSession.setActive;
-	return i({
-		mutationKey: t,
-		mutationFn: (t) => e.multiSession.setActive({
-			...t,
-			fetchOptions: {
-				...t?.fetchOptions,
-				throw: !0
-			}
-		})
-	});
+import { authQueryKeys } from "@better-auth-ui/core";
+import { multiSessionMutationKeys, multiSessionQueryKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+import { useSession } from "../../queries/auth/session-query";
+/**
+ * Mutation options factory for switching the active device session.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ */
+export function setActiveSessionOptions(authClient) {
+    const mutationKey = multiSessionMutationKeys.setActive;
+    const mutationFn = (params) => authClient.multiSession.setActive({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
 }
-function c(r, i) {
-	let c = o(), { refetch: l } = t(r, { refetchOnMount: !1 }), { data: u, refetch: d } = n(r, { refetchOnMount: !1 });
-	return a({
-		...s(r),
-		...i,
-		onSuccess: async (t, n, ...a) => {
-			let o = n?.sessionToken, s = u?.find(({ session: { token: e } }) => e === o);
-			s && c.setQueryData(e(r).queryKey, s), await l(), await d(), await i?.onSuccess?.(t, n, ...a);
-		}
-	});
+/**
+ * Create a mutation for switching the active device session.
+ *
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * and device sessions queries (see `meta.awaits`).
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useSetActiveSession(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...setActiveSessionOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [authQueryKeys.session, multiSessionQueryKeys.lists(userId)]
+        }
+    }, queryClient);
 }
-//#endregion
-export { s as setActiveSessionOptions, c as useSetActiveSession };

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

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

package/dist/mutations/organization/accept-invitation-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 acceptInvitationOptions(authClient) {
+    const mutationKey = organizationMutationKeys.acceptInvitation;
+    const mutationFn = (params) => authClient.organization.acceptInvitation({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useAcceptInvitation(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...acceptInvitationOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [
+                organizationQueryKeys.userInvitations.all(userId),
+                organizationQueryKeys.lists(userId)
+            ],
+            invalidates: [
+                organizationQueryKeys.fullDetails(userId),
+                organizationQueryKeys.activeOrganizations(userId)
+            ]
+        }
+    }, queryClient);
+}

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

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

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

@@ -0,0 +1,28 @@
+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 cancelInvitationOptions(authClient) {
+    const mutationKey = organizationMutationKeys.cancelInvitation;
+    const mutationFn = (params) => authClient.organization.cancelInvitation({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useCancelInvitation(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...cancelInvitationOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [
+                organizationQueryKeys.invitations.all(userId),
+                organizationQueryKeys.fullDetails(userId)
+            ]
+        }
+    }, queryClient);
+}

package/dist/mutations/organization/check-slug-mutation.d.ts

@@ -0,0 +1,21 @@
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+export type CheckSlugParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["checkSlug"]>[0];
+export type CheckSlugOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof checkSlugOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+/**
+ * Mutation options factory for checking organization slug availability.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export declare function checkSlugOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import("@tanstack/react-query").WithRequired<import("@tanstack/react-query").UseMutationOptions<{
+    status: boolean;
+}, BetterFetchError, CheckSlugParams<TAuthClient>, unknown>, "mutationKey">;
+/**
+ * Create a mutation for checking whether an organization slug is available.
+ *
+ * @param authClient - The Better Auth client with the organization plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export declare function useCheckSlug<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: CheckSlugOptions<TAuthClient>): import("@tanstack/react-query").UseMutationResult<{
+    status: boolean;
+}, BetterFetchError, CheckSlugParams<TAuthClient>, unknown>;

package/dist/mutations/organization/check-slug-mutation.js

@@ -0,0 +1,30 @@
+import { organizationMutationKeys } from "@better-auth-ui/core/plugins";
+import { mutationOptions, useMutation } from "@tanstack/react-query";
+/**
+ * Mutation options factory for checking organization slug availability.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function checkSlugOptions(authClient) {
+    const mutationKey = organizationMutationKeys.checkSlug;
+    const mutationFn = (params) => authClient.organization.checkSlug({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+/**
+ * Create a mutation for checking whether an organization slug is available.
+ *
+ * @param authClient - The Better Auth client with the organization plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useCheckSlug(authClient, options) {
+    return useMutation({
+        ...checkSlugOptions(authClient),
+        ...options
+    });
+}

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

@@ -0,0 +1,39 @@
+import { type QueryClient } from "@tanstack/react-query";
+import type { BetterFetchError } from "better-auth/react";
+import type { OrganizationAuthClient } from "../../lib/auth-client";
+export type CreateOrganizationParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["create"]>[0];
+export type CreateOrganizationOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof createOrganizationOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
+export declare function createOrganizationOptions<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;
+} & {
+    metadata: any;
+    members: ({
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: string;
+        createdAt: Date;
+    } | undefined)[];
+}, BetterFetchError, CreateOrganizationParams<TAuthClient>, unknown>, "mutationKey">;
+export declare function useCreateOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: CreateOrganizationOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: Date;
+    logo?: string | null | undefined | undefined;
+    metadata?: any;
+} & {
+    metadata: any;
+    members: ({
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: string;
+        createdAt: Date;
+    } | undefined)[];
+}, BetterFetchError, CreateOrganizationParams<TAuthClient>, unknown>;

package/dist/mutations/organization/create-organization-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 createOrganizationOptions(authClient) {
+    const mutationKey = organizationMutationKeys.create;
+    const mutationFn = (params) => authClient.organization.create({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useCreateOrganization(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...createOrganizationOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [organizationQueryKeys.lists(userId)],
+            invalidates: [
+                organizationQueryKeys.fullDetails(userId),
+                organizationQueryKeys.activeOrganizations(userId)
+            ]
+        }
+    }, queryClient);
+}

package/dist/mutations/organization/delete-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 DeleteOrganizationParams<TAuthClient extends OrganizationAuthClient> = Parameters<TAuthClient["organization"]["delete"]>[0];
+export type DeleteOrganizationOptions<TAuthClient extends OrganizationAuthClient> = Omit<ReturnType<typeof deleteOrganizationOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
+export declare function deleteOrganizationOptions<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, DeleteOrganizationParams<TAuthClient>, unknown>, "mutationKey">;
+export declare function useDeleteOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: DeleteOrganizationOptions<TAuthClient>, queryClient?: QueryClient): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: Date;
+    logo?: string | null | undefined | undefined;
+    metadata?: any;
+}, BetterFetchError, DeleteOrganizationParams<TAuthClient>, unknown>;

package/dist/mutations/organization/delete-organization-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 deleteOrganizationOptions(authClient) {
+    const mutationKey = organizationMutationKeys.delete;
+    const mutationFn = (params) => authClient.organization.delete({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useDeleteOrganization(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    return useMutation({
+        ...deleteOrganizationOptions(authClient),
+        ...options,
+        meta: {
+            awaits: [organizationQueryKeys.lists(userId)],
+            invalidates: [
+                organizationQueryKeys.fullDetails(userId),
+                organizationQueryKeys.activeOrganizations(userId)
+            ]
+        }
+    }, queryClient);
+}

package/dist/mutations/organization/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./accept-invitation-mutation";
+export * from "./cancel-invitation-mutation";
+export * from "./check-slug-mutation";
+export * from "./create-organization-mutation";
+export * from "./delete-organization-mutation";
+export * from "./invite-member-mutation";
+export * from "./leave-organization-mutation";
+export * from "./reject-invitation-mutation";
+export * from "./remove-member-mutation";
+export * from "./set-active-organization-mutation";
+export * from "./update-member-role-mutation";
+export * from "./update-organization-mutation";

package/dist/mutations/organization/index.js

@@ -0,0 +1,12 @@
+export * from "./accept-invitation-mutation";
+export * from "./cancel-invitation-mutation";
+export * from "./check-slug-mutation";
+export * from "./create-organization-mutation";
+export * from "./delete-organization-mutation";
+export * from "./invite-member-mutation";
+export * from "./leave-organization-mutation";
+export * from "./reject-invitation-mutation";
+export * from "./remove-member-mutation";
+export * from "./set-active-organization-mutation";
+export * from "./update-member-role-mutation";
+export * from "./update-organization-mutation";

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

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

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

@@ -0,0 +1,35 @@
+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 inviteMemberOptions(authClient) {
+    const mutationKey = organizationMutationKeys.inviteMember;
+    const mutationFn = (params) => authClient.organization.inviteMember({
+        ...params,
+        fetchOptions: { ...params?.fetchOptions, throw: true }
+    });
+    return mutationOptions({
+        mutationKey,
+        mutationFn
+    });
+}
+export function useInviteMember(authClient, options, queryClient) {
+    const { data: session } = useSession(authClient, undefined, queryClient);
+    const userId = session?.user.id;
+    const { data: activeOrganization } = useActiveOrganization(authClient, undefined, queryClient);
+    return useMutation({
+        ...inviteMemberOptions(authClient),
+        ...options,
+        mutationFn: (params) => authClient.organization.inviteMember({
+            ...params,
+            organizationId: params?.organizationId ?? activeOrganization?.id,
+            fetchOptions: { ...params?.fetchOptions, throw: true }
+        }),
+        meta: {
+            awaits: [
+                organizationQueryKeys.invitations.all(userId),
+                organizationQueryKeys.fullDetails(userId)
+            ]
+        }
+    }, queryClient);
+}