@better-auth-ui/solid 1.6.19

package/dist/mutations/organization/metadata.js

@@ -0,0 +1,27 @@
+import { organizationQueryKeys as e } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/metadata.ts
+var t = (t) => ({
+	awaits: [e.lists(t)],
+	invalidates: [e.fullDetails(t), e.activeOrganizations(t)]
+}), n = (t) => ({ awaits: [
+	e.lists(t),
+	e.fullDetails(t),
+	e.activeOrganizations(t)
+] }), r = t, i = (t) => ({
+	awaits: [e.activeOrganizations(t)],
+	invalidates: [e.lists(t)]
+}), a = (t) => ({ awaits: [e.invitations.all(t), e.fullDetails(t)] }), o = (t) => ({
+	awaits: [e.members.all(t), e.fullDetails(t)],
+	invalidates: [e.permissions.all(t)]
+}), s = (t) => ({
+	awaits: [e.members.all(t), e.fullDetails(t)],
+	invalidates: [e.lists(t)]
+}), c = (t) => ({
+	awaits: [e.members.all(t), e.fullDetails(t)],
+	invalidates: [e.lists(t), e.activeOrganizations(t)]
+}), l = (t) => ({
+	awaits: [e.userInvitations.all(t), e.lists(t)],
+	invalidates: [e.fullDetails(t), e.activeOrganizations(t)]
+}), u = (t) => ({ awaits: [e.invitations.all(t), e.fullDetails(t)] }), d = (t) => ({ awaits: [e.userInvitations.all(t)] });
+//#endregion
+export { l as acceptInvitationMeta, u as cancelInvitationMeta, t as createOrganizationMeta, r as deleteOrganizationMeta, a as inviteMemberMeta, c as leaveOrganizationMeta, o as memberRoleMeta, d as rejectInvitationMeta, s as removeMemberMeta, i as setActiveOrganizationMeta, n as updateOrganizationMeta };

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

@@ -0,0 +1,18 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type RejectInvitationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["rejectInvitation"]>[0];
+export type RejectInvitationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["rejectInvitation"]>;
+export declare function rejectInvitationOptions<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 useRejectInvitation<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: RejectInvitationOptions<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/reject-invitation-mutation.js

@@ -0,0 +1,12 @@
+import { rejectInvitationMeta 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/reject-invitation-mutation.ts
+function i(e) {
+	return t(e.organization.rejectInvitation, r.rejectInvitation);
+}
+function a(t, i) {
+	return n(t, t.organization.rejectInvitation, r.rejectInvitation, e, i);
+}
+//#endregion
+export { i as rejectInvitationOptions, a as useRejectInvitation };

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

@@ -0,0 +1,22 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type RemoveMemberParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["removeMember"]>[0];
+export type RemoveMemberOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["removeMember"]>;
+export declare function removeMemberOptions<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<{
+    memberIdOrEmail: string;
+    organizationId?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        memberIdOrEmail: string;
+        organizationId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useRemoveMember<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: RemoveMemberOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    memberIdOrEmail: string;
+    organizationId?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        memberIdOrEmail: string;
+        organizationId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { removeMemberMeta 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/remove-member-mutation.ts
+function i(e) {
+	return t(e.organization.removeMember, r.removeMember);
+}
+function a(t, i) {
+	return n(t, t.organization.removeMember, r.removeMember, e, i);
+}
+//#endregion
+export { i as removeMemberOptions, a as useRemoveMember };

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

@@ -0,0 +1,24 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type SetActiveOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["setActive"]>[0];
+export type SetActiveOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["setActive"]>;
+export declare function setActiveOrganizationOptions<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 | null | undefined;
+    organizationSlug?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        organizationId?: string | null | undefined;
+        organizationSlug?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}> | undefined, unknown>, "mutationKey">;
+export declare function useSetActiveOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: SetActiveOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    organizationId?: string | null | undefined;
+    organizationSlug?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        organizationId?: string | null | undefined;
+        organizationSlug?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}> | undefined, {
+    previousOrganizations: [readonly unknown[], unknown][];
+}>;

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

@@ -0,0 +1,35 @@
+import { useSession as e } from "../../queries/auth/session-query.js";
+import { setActiveOrganizationMeta as t } from "./metadata.js";
+import { createOrganizationMutationOptions as n } from "./utils.js";
+import { useListOrganizations as r } from "../../queries/organization/list-organizations-query.js";
+import "../../queries/organization/index.js";
+import { createMutation as i, useQueryClient as a } from "@tanstack/solid-query";
+import { organizationMutationKeys as o, organizationQueryKeys as s } from "@better-auth-ui/core/plugins";
+//#region src/mutations/organization/set-active-organization-mutation.ts
+function c(e) {
+	return n(e.organization.setActive, o.setActive);
+}
+function l(c, l) {
+	let u = e(c), d = a(), f = () => u.data?.user?.id, p = r(c);
+	return i(() => ({
+		...n(c.organization.setActive, o.setActive),
+		...l,
+		meta: t(f()),
+		onMutate: async (e) => {
+			await d.cancelQueries({ queryKey: s.activeOrganizations(f()) });
+			let t = d.getQueriesData({ queryKey: s.activeOrganizations(f()) });
+			if (e?.organizationId === null) return d.setQueriesData({ queryKey: s.activeOrganizations(f()) }, null), { previousOrganizations: t };
+			let n = p.data?.find((t) => e?.organizationId !== void 0 && t.id === e.organizationId || e?.organizationSlug !== void 0 && t.slug === e.organizationSlug);
+			return n && d.setQueriesData({ queryKey: s.activeOrganizations(f()) }, n), { previousOrganizations: t };
+		},
+		onError: (e, t, n) => {
+			let r = n?.previousOrganizations;
+			if (r?.length) for (let [e, t] of r) d.setQueryData(e, t);
+		},
+		onSettled: async () => {
+			await d.invalidateQueries({ queryKey: s.activeOrganizations(f()) });
+		}
+	}));
+}
+//#endregion
+export { c as setActiveOrganizationOptions, l as useSetActiveOrganization };

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

@@ -0,0 +1,26 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type UpdateMemberRoleParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["updateMemberRole"]>[0];
+export type UpdateMemberRoleOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["updateMemberRole"]>;
+export declare function updateMemberRoleOptions<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<{
+    role: "member" | import('better-auth').LiteralString | import('better-auth').LiteralString[] | "admin" | "owner" | ("member" | "admin" | "owner")[];
+    memberId: string;
+    organizationId?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        role: "member" | import('better-auth').LiteralString | import('better-auth').LiteralString[] | "admin" | "owner" | ("member" | "admin" | "owner")[];
+        memberId: string;
+        organizationId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useUpdateMemberRole<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UpdateMemberRoleOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    role: "member" | import('better-auth').LiteralString | import('better-auth').LiteralString[] | "admin" | "owner" | ("member" | "admin" | "owner")[];
+    memberId: string;
+    organizationId?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        role: "member" | import('better-auth').LiteralString | import('better-auth').LiteralString[] | "admin" | "owner" | ("member" | "admin" | "owner")[];
+        memberId: string;
+        organizationId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { memberRoleMeta 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/update-member-role-mutation.ts
+function i(e) {
+	return t(e.organization.updateMemberRole, r.updateMemberRole);
+}
+function a(t, i) {
+	return n(t, t.organization.updateMemberRole, r.updateMemberRole, e, i);
+}
+//#endregion
+export { i as updateMemberRoleOptions, a as useUpdateMemberRole };

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

@@ -0,0 +1,42 @@
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { OrganizationMutationOptions } from './utils';
+export type UpdateOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["update"]>[0];
+export type UpdateOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = OrganizationMutationOptions<TAuthClient["organization"]["update"]>;
+export declare function updateOrganizationOptions<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<{
+    data: {
+        name?: string | undefined;
+        slug?: string | undefined;
+        logo?: string | null | undefined;
+        metadata?: Record<string, any> | undefined;
+    } & Partial<{}>;
+    organizationId?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        data: {
+            name?: string | undefined;
+            slug?: string | undefined;
+            logo?: string | null | undefined;
+            metadata?: Record<string, any> | undefined;
+        } & Partial<{}>;
+        organizationId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useUpdateOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UpdateOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    data: {
+        name?: string | undefined;
+        slug?: string | undefined;
+        logo?: string | null | undefined;
+        metadata?: Record<string, any> | undefined;
+    } & Partial<{}>;
+    organizationId?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        data: {
+            name?: string | undefined;
+            slug?: string | undefined;
+            logo?: string | null | undefined;
+            metadata?: Record<string, any> | undefined;
+        } & Partial<{}>;
+        organizationId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

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

@@ -0,0 +1,12 @@
+import { updateOrganizationMeta 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/update-organization-mutation.ts
+function i(e) {
+	return t(e.organization.update, r.update);
+}
+function a(t, i) {
+	return n(t, t.organization.update, r.update, e, i);
+}
+//#endregion
+export { i as updateOrganizationOptions, a as useUpdateOrganization };

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

@@ -0,0 +1,8 @@
+import { CreateMutationOptions, MutationKey } from '@tanstack/solid-query';
+import { BetterFetchError } from 'better-auth/client';
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { MutationMethod } from '../create-auth-mutation';
+import { AuthMutationMeta } from './metadata';
+export type OrganizationMutationOptions<TMethod extends MutationMethod> = Omit<CreateMutationOptions<Awaited<ReturnType<TMethod>>, BetterFetchError, Parameters<TMethod>[0]>, "mutationKey" | "mutationFn" | "meta">;
+export declare function createOrganizationMutationOptions<TMethod extends MutationMethod, const TMutationKey extends MutationKey>(authFn: TMethod, mutationKey: TMutationKey): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<Awaited<ReturnType<TMethod>>, BetterFetchError, import('../create-auth-mutation').MutationParams<TMethod>, unknown>, "mutationKey">;
+export declare function useOrganizationMutation<TAuthClient extends OrganizationAuthClient, TMethod extends MutationMethod, const TMutationKey extends MutationKey>(authClient: TAuthClient, authFn: TMethod, mutationKey: TMutationKey, meta: (userId: string | undefined) => AuthMutationMeta, options?: OrganizationMutationOptions<TMethod>): import('@tanstack/solid-query').CreateMutationResult<Awaited<ReturnType<TMethod>>, BetterFetchError, import('../create-auth-mutation').MutationParams<TMethod>, unknown>;

package/dist/mutations/organization/utils.js

@@ -0,0 +1,17 @@
+import { useSession as e } from "../../queries/auth/session-query.js";
+import { createAuthMutationOptions as t } from "../create-auth-mutation.js";
+import { createMutation as n } from "@tanstack/solid-query";
+//#region src/mutations/organization/utils.ts
+function r(e, n) {
+	return t(e, n);
+}
+function i(t, i, a, o, s) {
+	let c = e(t);
+	return n(() => ({
+		...r(i, a),
+		...s,
+		meta: o(c.data?.user?.id)
+	}));
+}
+//#endregion
+export { r as createOrganizationMutationOptions, i as useOrganizationMutation };

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

@@ -0,0 +1,73 @@
+import { passkeyMutationKeys } from '@better-auth-ui/core/plugins';
+import { PasskeyAuthClient } from '../../lib/auth-client';
+import { useSessionScopedMutation } from '../use-session-scoped-mutation';
+export type AddPasskeyParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["passkey"]["addPasskey"]>[0];
+export type AddPasskeyOptions = Parameters<typeof useSessionScopedMutation<PasskeyAuthClient, PasskeyAuthClient["passkey"]["addPasskey"], typeof passkeyMutationKeys.addPasskey>>[4];
+export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<{
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    data: import('@better-auth/passkey').Passkey;
+    error: null;
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: import('@better-auth/passkey').Passkey;
+    error: null;
+} | {
+    data: null;
+    error: {
+        code: string;
+        message: string;
+        status: number;
+        statusText: string;
+    };
+}, import('better-auth/solid').BetterFetchError, {
+    fetchOptions?: import('better-auth').ClientFetchOption;
+    name?: string;
+    authenticatorAttachment?: "platform" | "cross-platform";
+    context?: string | null;
+    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+    useAutoRegister?: boolean;
+    returnWebAuthnResponse?: boolean;
+} | undefined, unknown>, "mutationKey">;
+export declare function useAddPasskey<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: AddPasskeyOptions): import('@tanstack/solid-query').CreateMutationResult<{
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    data: import('@better-auth/passkey').Passkey;
+    error: null;
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: import('@better-auth/passkey').Passkey;
+    error: null;
+} | {
+    data: null;
+    error: {
+        code: string;
+        message: string;
+        status: number;
+        statusText: string;
+    };
+}, import('better-auth/solid').BetterFetchError, {
+    fetchOptions?: import('better-auth').ClientFetchOption;
+    name?: string;
+    authenticatorAttachment?: "platform" | "cross-platform";
+    context?: string | null;
+    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+    useAutoRegister?: boolean;
+    returnWebAuthnResponse?: boolean;
+} | undefined, unknown>;

package/dist/mutations/passkey/add-passkey-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 { passkeyMutationKeys as n, passkeyQueryKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/passkey/add-passkey-mutation.ts
+function i(t) {
+	return e(t.passkey.addPasskey, n.addPasskey);
+}
+function a(e, i) {
+	return t(e, e.passkey.addPasskey, n.addPasskey, (e) => ({ awaits: [r.lists(e)] }), i);
+}
+//#endregion
+export { i as addPasskeyOptions, a as useAddPasskey };

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

@@ -0,0 +1,19 @@
+import { passkeyMutationKeys } from '@better-auth-ui/core/plugins';
+import { PasskeyAuthClient } from '../../lib/auth-client';
+import { useSessionScopedMutation } from '../use-session-scoped-mutation';
+export type DeletePasskeyParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["passkey"]["deletePasskey"]>[0];
+export type DeletePasskeyOptions = Parameters<typeof useSessionScopedMutation<PasskeyAuthClient, PasskeyAuthClient["passkey"]["deletePasskey"], typeof passkeyMutationKeys.deletePasskey>>[4];
+export declare function deletePasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    id: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        id: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useDeletePasskey<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: DeletePasskeyOptions): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    id: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        id: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

package/dist/mutations/passkey/delete-passkey-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 { passkeyMutationKeys as n, passkeyQueryKeys as r } from "@better-auth-ui/core/plugins";
+//#region src/mutations/passkey/delete-passkey-mutation.ts
+function i(t) {
+	return e(t.passkey.deletePasskey, n.deletePasskey);
+}
+function a(e, i) {
+	return t(e, e.passkey.deletePasskey, n.deletePasskey, (e) => ({ awaits: [r.lists(e)] }), i);
+}
+//#endregion
+export { i as deletePasskeyOptions, a as useDeletePasskey };

package/dist/mutations/passkey/sign-in-passkey-mutation.d.ts

@@ -0,0 +1,50 @@
+import { PasskeyAuthClient } from '../../lib/auth-client';
+export type SignInPasskeyParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["signIn"]["passkey"]>[0];
+export declare function signInPasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/solid-query').WithRequired<import('@tanstack/solid-query').MutationOptions<{
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    data: {
+        session: import('better-auth').Session;
+        user: import('better-auth').User;
+    };
+    error: null;
+} | {
+    data: null;
+    error: {
+        code: string;
+        message: string;
+        status: number;
+        statusText: string;
+    };
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: null;
+    error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+} | {
+    webauthn: {
+        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+    };
+    data: {
+        session: import('better-auth').Session;
+        user: import('better-auth').User;
+    };
+    error: null;
+}, import('better-auth/solid').BetterFetchError, {
+    autoFill?: boolean;
+    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+    returnWebAuthnResponse?: boolean;
+    fetchOptions?: import('better-auth').ClientFetchOption;
+} | undefined, unknown>, "mutationKey">;

package/dist/mutations/passkey/sign-in-passkey-mutation.js

@@ -0,0 +1,9 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { authQueryKeys as t } from "@better-auth-ui/core";
+import { passkeyMutationKeys as n } from "@better-auth-ui/core/plugins";
+//#region src/mutations/passkey/sign-in-passkey-mutation.ts
+function r(r) {
+	return e(r.signIn.passkey, n.signIn, { awaits: [t.session] });
+}
+//#endregion
+export { r as signInPasskeyOptions };

package/dist/mutations/settings/change-email-mutation.d.ts

@@ -0,0 +1,11 @@
+import { AuthClient } from '../../lib/auth-client';
+export type ChangeEmailParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["changeEmail"]>[0];
+export declare function changeEmailOptions<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<{
+    newEmail: string;
+    callbackURL?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        newEmail: string;
+        callbackURL?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;

package/dist/mutations/settings/change-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/settings/change-email-mutation.ts
+function r(r) {
+	return e(r.changeEmail, t.changeEmail, { awaits: [n.session] });
+}
+//#endregion
+export { r as changeEmailOptions };

package/dist/mutations/settings/change-password-mutation.d.ts

@@ -0,0 +1,13 @@
+import { AuthClient } from '../../lib/auth-client';
+export type ChangePasswordParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["changePassword"]>[0];
+export declare function changePasswordOptions<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<{
+    newPassword: string;
+    currentPassword: string;
+    revokeOtherSessions?: boolean | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        newPassword: string;
+        currentPassword: string;
+        revokeOtherSessions?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;

package/dist/mutations/settings/change-password-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/settings/change-password-mutation.ts
+function n(n) {
+	return e(n.changePassword, t.changePassword);
+}
+//#endregion
+export { n as changePasswordOptions };

package/dist/mutations/settings/delete-user-mutation.d.ts

@@ -0,0 +1,13 @@
+import { AuthClient } from '../../lib/auth-client';
+export type DeleteUserParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["deleteUser"]>[0];
+export declare function deleteUserOptions<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<{
+    callbackURL?: string | undefined;
+    password?: string | undefined;
+    token?: string | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        callbackURL?: string | undefined;
+        password?: string | undefined;
+        token?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}> | undefined, unknown>, "mutationKey">;

package/dist/mutations/settings/delete-user-mutation.js

@@ -0,0 +1,8 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { deleteUserMutationKeys as t } from "@better-auth-ui/core/plugins";
+//#region src/mutations/settings/delete-user-mutation.ts
+function n(n) {
+	return e(n.deleteUser, t.deleteUser);
+}
+//#endregion
+export { n as deleteUserOptions };

package/dist/mutations/settings/link-social-mutation.d.ts

@@ -0,0 +1,35 @@
+import { AuthClient } from '../../lib/auth-client';
+export type LinkSocialParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["linkSocial"]>[0];
+export declare function linkSocialOptions<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: unknown;
+    callbackURL?: string | undefined;
+    idToken?: {
+        token: string;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        refreshToken?: string | undefined;
+        scopes?: string[] | undefined;
+    } | undefined;
+    requestSignUp?: boolean | undefined;
+    scopes?: string[] | undefined;
+    errorCallbackURL?: string | undefined;
+    disableRedirect?: boolean | undefined;
+    additionalData?: Record<string, any> | undefined;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        provider: unknown;
+        callbackURL?: string | undefined;
+        idToken?: {
+            token: string;
+            nonce?: string | undefined;
+            accessToken?: string | undefined;
+            refreshToken?: string | undefined;
+            scopes?: string[] | undefined;
+        } | undefined;
+        requestSignUp?: boolean | undefined;
+        scopes?: string[] | undefined;
+        errorCallbackURL?: string | undefined;
+        disableRedirect?: boolean | 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/settings/link-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/settings/link-social-mutation.ts
+function n(n) {
+	return e(n.linkSocial, t.linkSocial);
+}
+//#endregion
+export { n as linkSocialOptions };

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

@@ -0,0 +1,19 @@
+import { authMutationKeys } from '@better-auth-ui/core';
+import { AuthClient } from '../../lib/auth-client';
+import { useSessionScopedMutation } from '../use-session-scoped-mutation';
+export type RevokeSessionParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["revokeSession"]>[0];
+export type RevokeSessionOptions = Parameters<typeof useSessionScopedMutation<AuthClient, AuthClient["revokeSession"], typeof authMutationKeys.revokeSession>>[4];
+export declare function revokeSessionOptions<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<{
+    token: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        token: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>, "mutationKey">;
+export declare function useRevokeSession<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: RevokeSessionOptions): import('@tanstack/solid-query').CreateMutationResult<any, import('better-auth/solid').BetterFetchError, import('better-auth').Prettify<{
+    token: string;
+} & {
+    fetchOptions?: import('better-auth').ClientFetchOption<Partial<{
+        token: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined> | undefined;
+}>, unknown>;

package/dist/mutations/settings/revoke-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 { authMutationKeys as n, authQueryKeys as r } from "@better-auth-ui/core";
+//#region src/mutations/settings/revoke-session-mutation.ts
+function i(t) {
+	return e(t.revokeSession, n.revokeSession);
+}
+function a(e, i) {
+	return t(e, e.revokeSession, n.revokeSession, (e) => ({ awaits: [r.listSessions(e)] }), i);
+}
+//#endregion
+export { i as revokeSessionOptions, a as useRevokeSession };