@better-auth-ui/solid 1.6.19

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

@@ -0,0 +1,53 @@
+import { AuthClient } from '../../lib/auth-client';
+export type SignInSocialParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signIn"]["social"]>[0];
+export declare function signInSocialOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    provider: (string & {}) | "linear" | "huggingface" | "github" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "slack" | "spotify" | "twitch" | "twitter" | "dropbox" | "kick" | "linkedin" | "gitlab" | "tiktok" | "reddit" | "roblox" | "salesforce" | "vk" | "zoom" | "notion" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
+    callbackURL?: string | undefined;
+    newUserCallbackURL?: string | undefined;
+    errorCallbackURL?: string | undefined;
+    disableRedirect?: boolean | undefined;
+    idToken?: {
+        token: string;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        refreshToken?: string | undefined;
+        expiresAt?: number | undefined;
+        user?: {
+            name?: {
+                firstName?: string | undefined;
+                lastName?: string | undefined;
+            } | undefined;
+            email?: string | undefined;
+        } | undefined;
+    } | undefined;
+    scopes?: string[] | undefined;
+    requestSignUp?: boolean | undefined;
+    loginHint?: string | undefined;
+    additionalData?: Record<string, any> | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        provider: (string & {}) | "linear" | "huggingface" | "github" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "slack" | "spotify" | "twitch" | "twitter" | "dropbox" | "kick" | "linkedin" | "gitlab" | "tiktok" | "reddit" | "roblox" | "salesforce" | "vk" | "zoom" | "notion" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
+        callbackURL?: string | undefined;
+        newUserCallbackURL?: string | undefined;
+        errorCallbackURL?: string | undefined;
+        disableRedirect?: boolean | undefined;
+        idToken?: {
+            token: string;
+            nonce?: string | undefined;
+            accessToken?: string | undefined;
+            refreshToken?: string | undefined;
+            expiresAt?: number | undefined;
+            user?: {
+                name?: {
+                    firstName?: string | undefined;
+                    lastName?: string | undefined;
+                } | undefined;
+                email?: string | undefined;
+            } | undefined;
+        } | undefined;
+        scopes?: string[] | undefined;
+        requestSignUp?: boolean | undefined;
+        loginHint?: string | undefined;
+        additionalData?: Record<string, any> | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;

package/dist/mutations/auth/sign-in-social-mutation.js

@@ -0,0 +1,8 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { authMutationKeys as t } from "@better-auth-ui/core";
+//#region src/mutations/auth/sign-in-social-mutation.ts
+function n(n) {
+	return e(n.signIn.social, t.signIn.social);
+}
+//#endregion
+export { n as signInSocialOptions };

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

@@ -0,0 +1,6 @@
+import { AuthClient } from '../../lib/auth-client';
+export type SignOutParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signOut"]>[0];
+export declare function signOutOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    query?: Record<string, any> | undefined;
+    fetchOptions?: import('better-auth').ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}> | undefined, unknown>, "mutationKey">;

package/dist/mutations/auth/sign-out-mutation.js

@@ -0,0 +1,8 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { authMutationKeys as t } from "@better-auth-ui/core";
+//#region src/mutations/auth/sign-out-mutation.ts
+function n(n) {
+	return e(n.signOut, t.signOut);
+}
+//#endregion
+export { n as signOutOptions };

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

@@ -0,0 +1,17 @@
+import { AuthClient } from '../../lib/auth-client';
+export type SignUpEmailParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["signUp"]["email"]>[0];
+export declare function signUpEmailOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    email: string;
+    name: string;
+    password: string;
+    image?: string | undefined;
+    callbackURL?: string | undefined;
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        name: string;
+        email: string;
+        password: string;
+        image?: string | undefined;
+        callbackURL?: string | undefined;
+        rememberMe?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;

package/dist/mutations/auth/sign-up-email-mutation.js

@@ -0,0 +1,8 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { authMutationKeys as t, authQueryKeys as n } from "@better-auth-ui/core";
+//#region src/mutations/auth/sign-up-email-mutation.ts
+function r(r) {
+	return e(r.signUp.email, t.signUp.email, { awaits: [n.session] });
+}
+//#endregion
+export { r as signUpEmailOptions };

package/dist/mutations/auth-mutation-options.d.ts

@@ -0,0 +1,10 @@
+import { CreateMutationOptions, MutationKey } from '@tanstack/solid-query';
+import { BetterFetchError } from 'better-auth/client';
+export type AuthMutationFn = (variables: any) => Promise<unknown>;
+export type AuthMutationFnData<TFn extends AuthMutationFn> = Awaited<ReturnType<TFn>>;
+export type AuthMutationFnVariables<TFn extends AuthMutationFn> = Parameters<TFn>[0] extends infer P ? undefined extends P ? // biome-ignore lint/suspicious/noConfusingVoidType: void allows no-arg mutate
+NonNullable<P> | void : P : never;
+export type AuthMutationOptions<TFn extends AuthMutationFn, TMutationKey extends MutationKey = MutationKey> = Omit<CreateMutationOptions<AuthMutationFnData<TFn>, BetterFetchError, AuthMutationFnVariables<TFn>>, "mutationKey"> & {
+    mutationKey: TMutationKey;
+};
+export declare function authMutationOptions<TFn extends AuthMutationFn, const TMutationKey extends MutationKey>(authFn: TFn, mutationKey: TMutationKey): AuthMutationOptions<TFn, TMutationKey>;

package/dist/mutations/auth-mutation-options.js

@@ -0,0 +1,19 @@
+import { mutationOptions as e } from "@tanstack/solid-query";
+//#region src/mutations/auth-mutation-options.ts
+function t(t, n) {
+	return e({
+		mutationKey: n,
+		mutationFn: (e) => {
+			let n = e ?? {};
+			return t({
+				...n,
+				fetchOptions: {
+					...n.fetchOptions,
+					throw: !0
+				}
+			});
+		}
+	});
+}
+//#endregion
+export { t as authMutationOptions };

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

@@ -0,0 +1,10 @@
+import { MutationKey, QueryKey } from '@tanstack/solid-query';
+import { BetterFetchError } from 'better-auth/client';
+export type MutationMethod<TData = unknown> = (params?: any) => Promise<TData>;
+export type MutationParams<TMethod extends MutationMethod> = Parameters<TMethod>[0];
+export type MutationData<TMethod extends MutationMethod> = Awaited<ReturnType<TMethod>>;
+export type AuthMutationMeta = {
+    invalidates?: Array<QueryKey>;
+    awaits?: Array<QueryKey>;
+};
+export declare function createAuthMutationOptions<TMethod extends MutationMethod, const TMutationKey extends MutationKey>(authFn: TMethod, mutationKey: TMutationKey, meta?: AuthMutationMeta): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<Awaited<ReturnType<TMethod>>, BetterFetchError, MutationParams<TMethod>, unknown>, "mutationKey">;

package/dist/mutations/create-auth-mutation.js

@@ -0,0 +1,20 @@
+import { mutationOptions as e } from "@tanstack/solid-query";
+//#region src/mutations/create-auth-mutation.ts
+function t(t, n, r) {
+	return e({
+		mutationKey: n,
+		mutationFn: (e) => {
+			let n = e ?? {};
+			return t({
+				...n,
+				fetchOptions: {
+					...n.fetchOptions,
+					throw: !0
+				}
+			});
+		},
+		...r ? { meta: r } : {}
+	});
+}
+//#endregion
+export { t as createAuthMutationOptions };

package/dist/mutations/magic-link/sign-in-magic-link-mutation.d.ts

@@ -0,0 +1,19 @@
+import { MagicLinkAuthClient } from '../../lib/auth-client';
+export type SignInMagicLinkParams<TAuthClient extends MagicLinkAuthClient> = Parameters<TAuthClient["signIn"]["magicLink"]>[0];
+export declare function signInMagicLinkOptions<TAuthClient extends MagicLinkAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    email: string;
+    name?: string | undefined;
+    callbackURL?: string | undefined;
+    newUserCallbackURL?: string | undefined;
+    errorCallbackURL?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        email: string;
+        name?: string | undefined;
+        callbackURL?: string | undefined;
+        newUserCallbackURL?: string | undefined;
+        errorCallbackURL?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;

package/dist/mutations/magic-link/sign-in-magic-link-mutation.js

@@ -0,0 +1,8 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { magicLinkMutationKeys as t } from "@better-auth-ui/core/plugins";
+//#region src/mutations/magic-link/sign-in-magic-link-mutation.ts
+function n(n) {
+	return e(n.signIn.magicLink, t.signIn);
+}
+//#endregion
+export { n as signInMagicLinkOptions };

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

@@ -0,0 +1,19 @@
+import { multiSessionMutationKeys } from '@better-auth-ui/core/plugins';
+import { MultiSessionAuthClient } from '../../lib/auth-client';
+import { useSessionScopedMutation } from '../use-session-scoped-mutation';
+export type RevokeMultiSessionParams<TAuthClient extends MultiSessionAuthClient> = Parameters<TAuthClient["multiSession"]["revoke"]>[0];
+export type RevokeMultiSessionOptions = Parameters<typeof useSessionScopedMutation<MultiSessionAuthClient, MultiSessionAuthClient["multiSession"]["revoke"], typeof multiSessionMutationKeys.revoke>>[4];
+export declare function revokeMultiSessionOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    sessionToken: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        sessionToken: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useRevokeMultiSession<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: RevokeMultiSessionOptions): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    sessionToken: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        sessionToken: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { useSessionScopedMutation as t } from "../use-session-scoped-mutation.js";
+import { multiSessionMutationKeys as n, multiSessionQueryKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/multi-session/revoke-multi-session-mutation.ts
+function i(t) {
+	return e(t.multiSession.revoke, n.revoke);
+}
+function a(e, i) {
+	return t(e, e.multiSession.revoke, n.revoke, (e) => ({ awaits: [r.lists(e)] }), i);
+}
+//#endregion
+export { i as revokeMultiSessionOptions, a as useRevokeMultiSession };

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

@@ -0,0 +1,19 @@
+import { multiSessionMutationKeys } from '@better-auth-ui/core/plugins';
+import { MultiSessionAuthClient } from '../../lib/auth-client';
+import { useSessionScopedMutation } from '../use-session-scoped-mutation';
+export type SetActiveSessionParams<TAuthClient extends MultiSessionAuthClient> = Parameters<TAuthClient["multiSession"]["setActive"]>[0];
+export type SetActiveSessionOptions = Parameters<typeof useSessionScopedMutation<MultiSessionAuthClient, MultiSessionAuthClient["multiSession"]["setActive"], typeof multiSessionMutationKeys.setActive>>[4];
+export declare function setActiveSessionOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    sessionToken: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        sessionToken: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useSetActiveSession<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: SetActiveSessionOptions): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    sessionToken: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        sessionToken: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,13 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { useSessionScopedMutation as t } from "../use-session-scoped-mutation.js";
+import { authQueryKeys as n } from "@better-auth-ui/core";
+import { multiSessionMutationKeys as r, multiSessionQueryKeys as i } from "@better-auth-ui/core/plugins";
+//#region src/mutations/multi-session/set-active-session-mutation.ts
+function a(t) {
+	return e(t.multiSession.setActive, r.setActive);
+}
+function o(e, a) {
+	return t(e, e.multiSession.setActive, r.setActive, (e) => ({ awaits: [n.session, i.lists(e)] }), a);
+}
+//#endregion
+export { a as setActiveSessionOptions, o as useSetActiveSession };

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

@@ -0,0 +1,18 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type AcceptInvitationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["acceptInvitation"]>[0];
+export type AcceptInvitationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["acceptInvitation"]>;
+export declare function acceptInvitationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    invitationId: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        invitationId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useAcceptInvitation<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: AcceptInvitationOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    invitationId: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        invitationId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { acceptInvitationMeta as e } from "./metadata.js";
+import { createOrganizationMutationOptions as t, useOrganizationMutation as n } from "./utils.js";
+import { organizationMutationKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/accept-invitation-mutation.ts
+function i(e) {
+	return t(e.organization.acceptInvitation, r.acceptInvitation);
+}
+function a(t, i) {
+	return n(t, t.organization.acceptInvitation, r.acceptInvitation, e, i);
+}
+//#endregion
+export { i as acceptInvitationOptions, a as useAcceptInvitation };

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

@@ -0,0 +1,18 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type CancelInvitationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["cancelInvitation"]>[0];
+export type CancelInvitationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["cancelInvitation"]>;
+export declare function cancelInvitationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    invitationId: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        invitationId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useCancelInvitation<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: CancelInvitationOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    invitationId: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        invitationId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { cancelInvitationMeta as e } from "./metadata.js";
+import { createOrganizationMutationOptions as t, useOrganizationMutation as n } from "./utils.js";
+import { organizationMutationKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/cancel-invitation-mutation.ts
+function i(e) {
+	return t(e.organization.cancelInvitation, r.cancelInvitation);
+}
+function a(t, i) {
+	return n(t, t.organization.cancelInvitation, r.cancelInvitation, e, i);
+}
+//#endregion
+export { i as cancelInvitationOptions, a as useCancelInvitation };

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

@@ -0,0 +1,18 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type CheckOrganizationSlugParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["checkSlug"]>[0];
+export type CheckOrganizationSlugOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["checkSlug"]>;
+export declare function checkOrganizationSlugOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    slug: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        slug: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useCheckOrganizationSlug<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: CheckOrganizationSlugOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    slug: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        slug: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,15 @@
+import { createOrganizationMutationOptions as e } from "./utils.js";
+import { createMutation as t } from "@tanstack/solid-query";
+import { organizationMutationKeys as n } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/check-slug-mutation.ts
+function r(t) {
+	return e(t.organization.checkSlug, n.checkSlug);
+}
+function i(e, n) {
+	return t(() => ({
+		...r(e),
+		...n
+	}));
+}
+//#endregion
+export { r as checkOrganizationSlugOptions, i as useCheckOrganizationSlug };

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

@@ -0,0 +1,38 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type CreateOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["create"]>[0];
+export type CreateOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["create"]>;
+export declare function createOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    name: string;
+    slug: string;
+    userId?: string | undefined;
+    logo?: string | null | undefined;
+    metadata?: Record<string, any> | undefined;
+    keepCurrentActiveOrganization?: boolean | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        name: string;
+        slug: string;
+        userId?: string | undefined;
+        logo?: string | null | undefined;
+        metadata?: Record<string, any> | undefined;
+        keepCurrentActiveOrganization?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useCreateOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: CreateOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    name: string;
+    slug: string;
+    userId?: string | undefined;
+    logo?: string | null | undefined;
+    metadata?: Record<string, any> | undefined;
+    keepCurrentActiveOrganization?: boolean | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        name: string;
+        slug: string;
+        userId?: string | undefined;
+        logo?: string | null | undefined;
+        metadata?: Record<string, any> | undefined;
+        keepCurrentActiveOrganization?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { createOrganizationMeta as e } from "./metadata.js";
+import { createOrganizationMutationOptions as t, useOrganizationMutation as n } from "./utils.js";
+import { organizationMutationKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/create-organization-mutation.ts
+function i(e) {
+	return t(e.organization.create, r.create);
+}
+function a(t, i) {
+	return n(t, t.organization.create, r.create, e, i);
+}
+//#endregion
+export { i as createOrganizationOptions, a as useCreateOrganization };

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

@@ -0,0 +1,18 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type DeleteOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["delete"]>[0];
+export type DeleteOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["delete"]>;
+export declare function deleteOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    organizationId: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        organizationId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useDeleteOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: DeleteOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    organizationId: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        organizationId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { deleteOrganizationMeta as e } from "./metadata.js";
+import { createOrganizationMutationOptions as t, useOrganizationMutation as n } from "./utils.js";
+import { organizationMutationKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/delete-organization-mutation.ts
+function i(e) {
+	return t(e.organization.delete, r.delete);
+}
+function a(t, i) {
+	return n(t, t.organization.delete, r.delete, e, i);
+}
+//#endregion
+export { i as deleteOrganizationOptions, a as useDeleteOrganization };

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

@@ -0,0 +1,13 @@
+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 './metadata';
+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,13 @@
+import "./metadata.js";
+import "./accept-invitation-mutation.js";
+import "./cancel-invitation-mutation.js";
+import "./check-slug-mutation.js";
+import "./create-organization-mutation.js";
+import "./delete-organization-mutation.js";
+import "./invite-member-mutation.js";
+import "./leave-organization-mutation.js";
+import "./reject-invitation-mutation.js";
+import "./remove-member-mutation.js";
+import "./set-active-organization-mutation.js";
+import "./update-member-role-mutation.js";
+import "./update-organization-mutation.js";

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

@@ -0,0 +1,30 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type InviteMemberParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["inviteMember"]>[0];
+export type InviteMemberOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["inviteMember"]>;
+export declare function inviteMemberOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    email: string;
+    role: ("member" | "admin" | "owner") | ("member" | "admin" | "owner")[];
+    organizationId?: string | undefined;
+    resend?: boolean | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        email: string;
+        role: ("member" | "admin" | "owner") | ("member" | "admin" | "owner")[];
+        organizationId?: string | undefined;
+        resend?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useInviteMember<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: InviteMemberOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    email: string;
+    role: ("member" | "admin" | "owner") | ("member" | "admin" | "owner")[];
+    organizationId?: string | undefined;
+    resend?: boolean | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        email: string;
+        role: ("member" | "admin" | "owner") | ("member" | "admin" | "owner")[];
+        organizationId?: string | undefined;
+        resend?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { inviteMemberMeta as e } from "./metadata.js";
+import { createOrganizationMutationOptions as t, useOrganizationMutation as n } from "./utils.js";
+import { organizationMutationKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/invite-member-mutation.ts
+function i(e) {
+	return t(e.organization.inviteMember, r.inviteMember);
+}
+function a(t, i) {
+	return n(t, t.organization.inviteMember, r.inviteMember, e, i);
+}
+//#endregion
+export { i as inviteMemberOptions, a as useInviteMember };

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

@@ -0,0 +1,18 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type LeaveOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["leave"]>[0];
+export type LeaveOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["leave"]>;
+export declare function leaveOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    organizationId: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        organizationId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useLeaveOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: LeaveOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    organizationId: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        organizationId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { leaveOrganizationMeta as e } from "./metadata.js";
+import { createOrganizationMutationOptions as t, useOrganizationMutation as n } from "./utils.js";
+import { organizationMutationKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/leave-organization-mutation.ts
+function i(e) {
+	return t(e.organization.leave, r.leave);
+}
+function a(t, i) {
+	return n(t, t.organization.leave, r.leave, e, i);
+}
+//#endregion
+export { i as leaveOrganizationOptions, a as useLeaveOrganization };

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

@@ -0,0 +1,13 @@
+import { AuthMutationMeta } from '../create-auth-mutation';
+export type { AuthMutationMeta };
+export declare const createOrganizationMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const updateOrganizationMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const deleteOrganizationMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const setActiveOrganizationMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const inviteMemberMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const memberRoleMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const removeMemberMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const leaveOrganizationMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const acceptInvitationMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const cancelInvitationMeta: (userId: string | undefined) => AuthMutationMeta;
+export declare const rejectInvitationMeta: (userId: string | undefined) => AuthMutationMeta;