@better-auth-ui/react 1.6.8 → 1.6.10

package/dist/lib/auth-client.d.ts

@@ -1,6 +1,6 @@
 import { apiKeyClient } from '@better-auth/api-key/client';
 import { passkeyClient } from '@better-auth/passkey/client';
-import { magicLinkClient, multiSessionClient, usernameClient } from 'better-auth/client/plugins';
+import { magicLinkClient, multiSessionClient, organizationClient, usernameClient } from 'better-auth/client/plugins';
 import { createAuthClient } from 'better-auth/react';
 export type AuthClient = ReturnType<typeof createAuthClient>;
 export type MagicLinkAuthClient = ReturnType<typeof createAuthClient<{
@@ -18,6 +18,9 @@ export type ApiKeyAuthClient = ReturnType<typeof createAuthClient<{
 export type UsernameAuthClient = ReturnType<typeof createAuthClient<{
     plugins: [ReturnType<typeof usernameClient>];
 }>>;
+export type OrganizationAuthClient = ReturnType<typeof createAuthClient<{
+    plugins: [ReturnType<typeof organizationClient<object>>];
+}>>;
 /**
  * Unwraps a Better Auth client method's `data` payload.
  *

package/dist/lib/auth-plugin.d.ts

@@ -1,5 +1,6 @@
 import { AuthPluginBase, AuthView } from '@better-auth-ui/core';
 import { ComponentType, ReactNode } from 'react';
+import { SettingsTab } from './settings-tab';
 export type { AuthPluginViewPaths } from '@better-auth-ui/core';
 /** Props for plugin-contributed auth buttons (e.g. passkey, magic link). */
 export type AuthButtonProps = {
@@ -18,9 +19,16 @@ export type AccountCardProps = {
     className?: string;
     children?: ReactNode;
 };
+/** Props for plugin-contributed cards under `/organization/...` settings. */
+export type OrganizationCardProps = {
+    className?: string;
+    children?: ReactNode;
+};
 /** Props for plugin-contributed items in the `UserButton` dropdown. */
 export type UserMenuItemProps = {
     className?: string;
+    /** When true, the subtitle line (email when name/username is shown) is hidden. */
+    hideSubtitle?: boolean;
 };
 /** Framework-agnostic slot component shapes. UI packages narrow these via `TComponents`. */
 export type AuthPluginComponents = {
@@ -32,6 +40,8 @@ export type AuthPluginComponents = {
     securityCards?: ComponentType<SecurityCardProps>[];
     /** Rendered as cards inside account settings. */
     accountCards?: ComponentType<AccountCardProps>[];
+    /** Rendered as cards inside the active organization's settings. */
+    organizationCards?: ComponentType<OrganizationCardProps>[];
     /** Rendered as items inside the `UserButton` dropdown. */
     userMenuItems?: ComponentType<UserMenuItemProps>[];
 };
@@ -58,4 +68,10 @@ export type AuthPluginFallbackViews<TAuthViewProps> = {
 export type AuthPlugin<TComponents = AuthPluginComponents, TAuthViewProps = any, TSettingsViewProps = any> = AuthPluginBase & TComponents & {
     views?: AuthPluginViews<TAuthViewProps, TSettingsViewProps>;
     fallbackViews?: AuthPluginFallbackViews<TAuthViewProps>;
+    /**
+     * Tabs the plugin contributes to the settings page. Each entry is a
+     * {@link SettingsTab} (`view`, `label`, `component`). Read at runtime via
+     * `useAuthPlugin(plugin).settingsTabs`.
+     */
+    settingsTabs?: SettingsTab[];
 };

package/dist/lib/auth-server.d.ts

@@ -1,6 +1,7 @@
+import { apiKey } from '@better-auth/api-key';
 import { passkey } from '@better-auth/passkey';
 import { Auth } from 'better-auth';
-import { magicLink, multiSession, username } from 'better-auth/plugins';
+import { magicLink, multiSession, organization, username } from 'better-auth/plugins';
 export type AuthServer = Pick<Auth, "api">;
 export type MagicLinkAuthServer = Pick<Auth<{
     plugins: [ReturnType<typeof magicLink>];
@@ -11,6 +12,12 @@ export type MultiSessionAuthServer = Pick<Auth<{
 export type PasskeyAuthServer = Pick<Auth<{
     plugins: [ReturnType<typeof passkey>];
 }>, "api">;
+export type ApiKeyAuthServer = Pick<Auth<{
+    plugins: [ReturnType<typeof apiKey>];
+}>, "api">;
 export type UsernameAuthServer = Pick<Auth<{
     plugins: [ReturnType<typeof username>];
 }>, "api">;
+export type OrganizationAuthServer = Pick<Auth<{
+    plugins: [ReturnType<typeof organization>];
+}>, "api">;

package/dist/lib/settings-tab.d.ts

@@ -0,0 +1,19 @@
+import { SettingsView } from '@better-auth-ui/core';
+import { ComponentType, ReactNode } from 'react';
+/**
+ * Tab contributions for the settings page.
+ *
+ * Plugins declare `settingsTabs` on their object to add extra tabs.
+ * Read at runtime via `useAuthPlugin(plugin).settingsTabs`.
+ */
+export interface SettingsTab {
+    /**
+     * Settings view id — must match a key on `plugin.viewPaths.settings` and
+     * {@link SettingsView} (including keys added via `declare module` augmentation).
+     */
+    view: SettingsView;
+    /** Display label */
+    label: ReactNode;
+    /** Component rendered in the tab panel */
+    component: ComponentType<any>;
+}

package/dist/mutations/api-key/create-api-key-mutation.d.ts

@@ -1,7 +1,8 @@
+import { QueryClient } from '@tanstack/react-query';
 import { BetterFetchError } from 'better-auth/react';
 import { ApiKeyAuthClient } from '../../lib/auth-client';
-export type CreateApiKeyParams<TAuthClient extends ApiKeyAuthClient> = Parameters<TAuthClient["apiKey"]["create"]>[0];
-export type CreateApiKeyOptions<TAuthClient extends ApiKeyAuthClient> = Omit<ReturnType<typeof createApiKeyOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+export type CreateApiKeyParams<TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient> = Parameters<TAuthClient["apiKey"]["create"]>[0];
+export type CreateApiKeyOptions<TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient> = Omit<ReturnType<typeof createApiKeyOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * Mutation options factory for creating an API key.
  *
@@ -34,12 +35,13 @@ export declare function createApiKeyOptions<TAuthClient extends ApiKeyAuthClient
 /**
  * Create a mutation for creating an API key.
  *
- * Refetches the user's API key list on success unless disabled via options.
+ * On success, `MutationInvalidator` awaits invalidation of the user's API key
+ * list queries (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client with the API key plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
-export declare function useCreateApiKey<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, options?: CreateApiKeyOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+export declare function useCreateApiKey<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, options?: CreateApiKeyOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseMutationResult<{
     key: string;
     metadata: any;
     permissions: any;

package/dist/mutations/api-key/delete-api-key-mutation.d.ts

@@ -1,7 +1,8 @@
+import { QueryClient } from '@tanstack/react-query';
 import { BetterFetchError } from 'better-auth/react';
 import { ApiKeyAuthClient } from '../../lib/auth-client';
-export type DeleteApiKeyParams<TAuthClient extends ApiKeyAuthClient> = Parameters<TAuthClient["apiKey"]["delete"]>[0];
-export type DeleteApiKeyOptions<TAuthClient extends ApiKeyAuthClient> = Omit<ReturnType<typeof deleteApiKeyOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+export type DeleteApiKeyParams<TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient> = Parameters<TAuthClient["apiKey"]["delete"]>[0];
+export type DeleteApiKeyOptions<TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient> = Omit<ReturnType<typeof deleteApiKeyOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * Mutation options factory for deleting an API key.
  *
@@ -13,9 +14,12 @@ export declare function deleteApiKeyOptions<TAuthClient extends ApiKeyAuthClient
 /**
  * Create a mutation for deleting an API key.
  *
+ * On success, `MutationInvalidator` awaits invalidation of the user's API key
+ * list queries (see `meta.awaits`).
+ *
  * @param authClient - The Better Auth client with the API key plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
-export declare function useDeleteApiKey<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, options?: DeleteApiKeyOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+export declare function useDeleteApiKey<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, options?: DeleteApiKeyOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseMutationResult<{
     success: boolean;
 }, BetterFetchError, DeleteApiKeyParams<TAuthClient>, unknown>;

package/dist/mutations/auth/sign-in-email-mutation.d.ts

@@ -1,7 +1,8 @@
+import { QueryClient } from '@tanstack/react-query';
 import { BetterFetchError } from 'better-auth/react';
 import { AuthClient } from '../../lib/auth-client';
 export type SignInEmailParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signIn"]["email"]>[0];
-export type SignInEmailOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof signInEmailOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+export type SignInEmailOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof signInEmailOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * Mutation options factory for email/password sign-in.
  *
@@ -38,14 +39,13 @@ export declare function signInEmailOptions<TAuthClient extends AuthClient>(authC
 /**
  * Create a mutation for email/password sign-in.
  *
- * Wraps `authClient.signIn.email`, resets the session query on success so
- * the new session is refetched, and forwards React Query mutation options
- * such as `onSuccess`, `onError`, and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the new session is refetched (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client.
  * @param options - React Query options forwarded to `useMutation`.
  */
-export declare function useSignInEmail<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignInEmailOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<Omit<{
+export declare function useSignInEmail<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignInEmailOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseMutationResult<Omit<{
     redirect: boolean;
     token: string;
     url?: string | undefined;

package/dist/mutations/auth/sign-out-mutation.d.ts

@@ -1,3 +1,4 @@
+import { QueryClient } from '@tanstack/react-query';
 import { BetterFetchError } from 'better-auth/react';
 import { AuthClient } from '../../lib/auth-client';
 export type SignOutParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signOut"]>[0];
@@ -13,13 +14,14 @@ export declare function signOutOptions<TAuthClient extends AuthClient>(authClien
 /**
  * Create a mutation for signing the current user out.
  *
- * Wraps `authClient.signOut`, removes all cached auth queries on success,
- * and forwards React Query mutation options such as `onSuccess`, `onError`,
- * and `retry`.
+ * On success, removes every cached auth query so no stale data leaks across
+ * accounts. Sign-out uses a direct `removeQueries` call (rather than the
+ * `meta.awaits` / `meta.invalidates` pattern) because the goal is to drop
+ * cache entries entirely, not to refetch them.
  *
  * @param authClient - The Better Auth client.
  * @param options - React Query options forwarded to `useMutation`.
  */
-export declare function useSignOut<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignOutOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<{
+export declare function useSignOut<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignOutOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseMutationResult<{
     success: boolean;
 }, BetterFetchError, void | SignOutParams<TAuthClient> | undefined, unknown>;

package/dist/mutations/auth/sign-up-email-mutation.d.ts

@@ -1,7 +1,8 @@
+import { QueryClient } from '@tanstack/react-query';
 import { BetterFetchError } from 'better-auth/react';
 import { AuthClient } from '../../lib/auth-client';
 export type SignUpEmailParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signUp"]["email"]>[0];
-export type SignUpEmailOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof signUpEmailOptions<TAuthClient>>, "mutationKey" | "mutationFn">;
+export type SignUpEmailOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof signUpEmailOptions<TAuthClient>>, "mutationKey" | "mutationFn" | "meta">;
 /**
  * Mutation options factory for email/password sign-up.
  *
@@ -53,14 +54,13 @@ export declare function signUpEmailOptions<TAuthClient extends AuthClient>(authC
 /**
  * Create a mutation for email/password sign-up.
  *
- * Wraps `authClient.signUp.email`, resets the session query on success so
- * the new session is refetched, and forwards React Query mutation options
- * such as `onSuccess`, `onError`, and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the new session is refetched (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client.
  * @param options - React Query options forwarded to `useMutation`.
  */
-export declare function useSignUpEmail<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignUpEmailOptions<TAuthClient>): import('@tanstack/react-query').UseMutationResult<(Omit<{
+export declare function useSignUpEmail<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: SignUpEmailOptions<TAuthClient>, queryClient?: QueryClient): import('@tanstack/react-query').UseMutationResult<(Omit<{
     token: null;
     user: {
         id: string;

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

@@ -1,7 +1,8 @@
+import { QueryClient } from '@tanstack/react-query';
 import { BetterFetchError } from 'better-auth/react';
 import { 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.
  *
@@ -13,13 +14,12 @@ export declare function revokeMultiSessionOptions<TAuthClient extends MultiSessi
 /**
  * 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/set-active-session-mutation.d.ts

@@ -1,7 +1,8 @@
+import { QueryClient } from '@tanstack/react-query';
 import { BetterFetchError } from 'better-auth/react';
 import { 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.
  *
@@ -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/organization/accept-invitation-mutation.d.ts

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

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

@@ -0,0 +1,21 @@
+import { BetterFetchError } from 'better-auth/react';
+import { 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/create-organization-mutation.d.ts

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

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

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

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

@@ -0,0 +1,31 @@
+import { QueryClient } from '@tanstack/react-query';
+import { BetterFetchError } from 'better-auth/react';
+import { 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>;