@better-auth-ui/solid 1.6.19

package/dist/mutations/settings/unlink-account-mutation.d.ts

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

package/dist/mutations/settings/unlink-account-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/unlink-account-mutation.ts
+function i(t) {
+	return e(t.unlinkAccount, n.unlinkAccount);
+}
+function a(e, i) {
+	return t(e, e.unlinkAccount, n.unlinkAccount, (e) => ({ awaits: [r.listAccounts(e)] }), i);
+}
+//#endregion
+export { i as unlinkAccountOptions, a as useUnlinkAccount };

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

@@ -0,0 +1,6 @@
+import { AuthClient } from '../../lib/auth-client';
+export type UpdateUserParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["updateUser"]>[0];
+export declare function updateUserOptions<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<import('better-auth/client').InferUserUpdateCtx<import('better-auth').BetterAuthClientOptions, import('better-auth').ClientFetchOption<Partial<Partial<{}> & {
+    name?: string | undefined;
+    image?: string | undefined | null;
+}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>> | undefined, unknown>, "mutationKey">;

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

package/dist/mutations/use-session-scoped-mutation.d.ts

@@ -0,0 +1,17 @@
+import { CreateMutationOptions, MutationKey } from '@tanstack/solid-query';
+import { BetterFetchError } from 'better-auth/client';
+import { AuthClient } from '../lib/auth-client';
+import { AuthMutationMeta, MutationMethod } from './create-auth-mutation';
+export type SessionScopedMutationOptions<TMethod extends MutationMethod> = Omit<CreateMutationOptions<Awaited<ReturnType<TMethod>>, BetterFetchError, Parameters<TMethod>[0]>, "mutationKey" | "mutationFn" | "meta">;
+/**
+ * Create a mutation whose `meta` is derived from the current session's userId.
+ *
+ * This mirrors `useOrganizationMutation` for non-org domains: it reads the
+ * session reactively and passes the userId to a meta factory function so that
+ * `MutationInvalidator` can invalidate the correct scoped query keys.
+ *
+ * NOTE: `options` must NEVER contain a `meta` property — the type Omit
+ * enforces this at the type level, and the explicit `meta:` assignment below
+ * will silently override anything passed via options.
+ */
+export declare function useSessionScopedMutation<TAuthClient extends AuthClient, TMethod extends MutationMethod, const TMutationKey extends MutationKey>(authClient: TAuthClient, authFn: TMethod, mutationKey: TMutationKey, meta: (userId: string | undefined) => AuthMutationMeta, options?: SessionScopedMutationOptions<TMethod>): import('@tanstack/solid-query').CreateMutationResult<Awaited<ReturnType<TMethod>>, BetterFetchError, import('./create-auth-mutation').MutationParams<TMethod>, unknown>;

package/dist/mutations/use-session-scoped-mutation.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/use-session-scoped-mutation.ts
+function r(r, i, a, o, s) {
+	let c = e(r);
+	return n(() => {
+		let e = c.data?.user?.id;
+		return e || console.debug(`[useSessionScopedMutation] userId is undefined for mutation "${String(a)}". Cache invalidation will be a no-op until the session loads.`), {
+			...t(i, a),
+			...s,
+			meta: o(e)
+		};
+	});
+}
+//#endregion
+export { r as useSessionScopedMutation };

package/dist/mutations/username/is-username-available-mutation.d.ts

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

package/dist/mutations/username/is-username-available-mutation.js

@@ -0,0 +1,8 @@
+import { createAuthMutationOptions as e } from "../create-auth-mutation.js";
+import { usernameMutationKeys as t } from "@better-auth-ui/core/plugins";
+//#region src/mutations/username/is-username-available-mutation.ts
+function n(n) {
+	return e(n.isUsernameAvailable, t.isUsernameAvailable);
+}
+//#endregion
+export { n as isUsernameAvailableOptions };

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

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

package/dist/mutations/username/sign-in-username-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 { usernameMutationKeys as n } from "@better-auth-ui/core/plugins";
+//#region src/mutations/username/sign-in-username-mutation.ts
+function r(r) {
+	return e(r.signIn.username, n.signIn, { awaits: [t.session] });
+}
+//#endregion
+export { r as signInUsernameOptions };

package/dist/plugins/captcha-plugin.d.ts

@@ -0,0 +1,29 @@
+import { Component } from 'solid-js';
+/** Props passed to the consumer's `render` component. */
+export type CaptchaRenderProps = {
+    /** Call once the user solves the captcha. */
+    setToken: (token: string) => void;
+    /** Call on error/expire to clear the token. */
+    clearToken: () => void;
+    /**
+     * Register your widget's `reset()`. Forms call it after a failed
+     * submission since captcha tokens are single-use. Pass `null` on cleanup.
+     */
+    setReset: (reset: (() => void) | null) => void;
+};
+export type CaptchaPluginOptions = {
+    /** Renders the captcha widget. Wire `setToken`, `clearToken`, and `setReset`. */
+    render: Component<CaptchaRenderProps>;
+};
+/**
+ * Provider-agnostic captcha plugin. Forwards the resolved token via the
+ * `x-captcha-response` header on Better Auth requests.
+ */
+export declare const captchaPlugin: ((args_0: CaptchaPluginOptions) => {
+    render: Component<CaptchaRenderProps>;
+    captchaComponent: () => import("solid-js").JSX.Element;
+} & {
+    id: "captcha";
+}) & {
+    id: "captcha";
+};

package/dist/plugins/captcha-plugin.js

@@ -0,0 +1,26 @@
+import { useFetchOptions as e } from "../lib/fetch-options-provider.js";
+import { onCleanup as t } from "solid-js";
+import { createComponent as n } from "solid-js/web";
+import { createAuthPlugin as r } from "@better-auth-ui/core";
+//#region src/plugins/captcha-plugin.tsx
+var i = r("captcha", ({ render: r }) => ({
+	render: r,
+	captchaComponent: () => {
+		let { setFetchOptions: i, registerReset: a } = e();
+		return t(() => {
+			i(void 0), a(null);
+		}), n(r, {
+			setToken: (e) => {
+				i({ headers: { "x-captcha-response": e } });
+			},
+			clearToken: () => {
+				i(void 0);
+			},
+			setReset: (e) => {
+				a(e);
+			}
+		});
+	}
+}));
+//#endregion
+export { i as captchaPlugin };

package/dist/plugins.d.ts

@@ -0,0 +1,2 @@
+export type { AuthPlugin } from './lib/auth-plugin';
+export * from './plugins/captcha-plugin';

package/dist/plugins.js

@@ -0,0 +1,2 @@
+import { captchaPlugin as e } from "./plugins/captcha-plugin.js";
+export { e as captchaPlugin };

package/dist/queries/api-key/list-api-keys-query.d.ts

@@ -0,0 +1,44 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { ApiKeyAuthClient, InferData } from '../../lib/auth-client';
+export type ListApiKeysData<TAuthClient extends ApiKeyAuthClient> = InferData<TAuthClient["apiKey"]["list"]>;
+export type ListApiKeysParams<TAuthClient extends ApiKeyAuthClient> = Parameters<TAuthClient["apiKey"]["list"]>[0];
+export type ListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> = Omit<ReturnType<typeof listApiKeysOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListApiKeysParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "apiKey", "list", {
+    configId?: string | undefined;
+    organizationId?: string | undefined;
+    limit?: unknown;
+    offset?: unknown;
+    sortBy?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+} | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "apiKey", "list", {
+        configId?: string | undefined;
+        organizationId?: string | undefined;
+        limit?: unknown;
+        offset?: unknown;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "apiKey", "list", {
+        configId?: string | undefined;
+        organizationId?: string | undefined;
+        limit?: unknown;
+        offset?: unknown;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListApiKeys: <TAuthClient extends ApiKeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListApiKeysParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListApiKeys: <TAuthClient extends ApiKeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListApiKeysParams<TAuthClient>) => Promise<void>;
+export declare const fetchListApiKeys: <TAuthClient extends ApiKeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListApiKeysParams<TAuthClient>) => Promise<unknown>;
+export type UseListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> = ListApiKeysOptions<TAuthClient> & ListApiKeysParams<TAuthClient>;
+export declare function useListApiKeys<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, options?: UseListApiKeysOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/api-key/list-api-keys-query.js

@@ -0,0 +1,17 @@
+import { useSession as e } from "../auth/session-query.js";
+import { createUserScopedOptions as t, createUserScopedQuery as n, ensureUserScopedQuery as r, fetchUserScopedQuery as i, getSessionUserId as a, prefetchUserScopedQuery as o } from "../create-user-scoped-query.js";
+import { apiKeyQueryKeys as s } from "@better-auth-ui/core/plugins";
+//#region src/queries/api-key/list-api-keys-query.ts
+function c(e, n, r) {
+	return t(s.list(n, r?.query), e.apiKey.list, r);
+}
+var l = (e, t, n, i) => r(e, s.list(n, i?.query), t.apiKey.list, i), u = (e, t, n, r) => o(e, s.list(n, r?.query), t.apiKey.list, r), d = (e, t, n, r) => i(e, s.list(n, r?.query), t.apiKey.list, r);
+function f(t, r = {}) {
+	let i = e(t), o = () => a(i), { query: c, fetchOptions: l, ...u } = r;
+	return n(() => s.list(o(), c), t.apiKey.list, () => ({
+		query: c,
+		fetchOptions: l
+	}), () => !!o(), () => u);
+}
+//#endregion
+export { l as ensureListApiKeys, d as fetchListApiKeys, c as listApiKeysOptions, u as prefetchListApiKeys, f as useListApiKeys };

package/dist/queries/auth/session-query.d.ts

@@ -0,0 +1,22 @@
+import { DataTag, QueryClient } from '@tanstack/solid-query';
+import { BetterFetchError } from 'better-auth/client';
+import { AuthClient, InferData } from '../../lib/auth-client';
+export type SessionData<TAuthClient extends AuthClient = AuthClient> = InferData<TAuthClient["getSession"]>;
+export type Session<TAuthClient extends AuthClient = AuthClient> = NonNullable<SessionData<TAuthClient>>;
+export type SessionParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["getSession"]>[0];
+export type SessionOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof sessionOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function sessionOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, params?: SessionParams<TAuthClient>): (import('@tanstack/solid-query').QueryOptions<InferData<TAuthClient["getSession"]>, BetterFetchError, InferData<TAuthClient["getSession"]>, readonly unknown[]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly unknown[] & {
+        [dataTagSymbol]: InferData<TAuthClient["getSession"]>;
+        [dataTagErrorSymbol]: BetterFetchError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "getSession"], InferData<TAuthClient["getSession"]>, BetterFetchError>;
+};
+export declare const ensureSession: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, params?: SessionParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchSession: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, params?: SessionParams<TAuthClient>) => Promise<void>;
+export declare const fetchSession: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, params?: SessionParams<TAuthClient>) => Promise<unknown>;
+export type UseSessionOptions<TAuthClient extends AuthClient> = SessionOptions<TAuthClient> & SessionParams<TAuthClient>;
+export declare function useSession<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseSessionOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<InferData<TAuthClient["getSession"]>, BetterFetchError>;

package/dist/queries/auth/session-query.js

@@ -0,0 +1,32 @@
+import { createQuery as e, queryOptions as t } from "@tanstack/solid-query";
+import { authQueryKeys as n } from "@better-auth-ui/core";
+//#region src/queries/auth/session-query.ts
+function r(e, r) {
+	let i = n.session;
+	return t({
+		queryKey: i,
+		queryFn: ({ signal: t }) => e.getSession({
+			...r,
+			fetchOptions: {
+				...r?.fetchOptions,
+				signal: t,
+				throw: !0
+			}
+		})
+	});
+}
+var i = (e, t, n) => e.ensureQueryData(r(t, n)), a = (e, t, n) => e.prefetchQuery(r(t, n)), o = (e, t, n) => e.fetchQuery(r(t, n));
+function s(t, n = {}) {
+	return e(() => {
+		let { query: e, fetchOptions: i, ...a } = n;
+		return {
+			...r(t, {
+				query: e,
+				fetchOptions: i
+			}),
+			...a
+		};
+	});
+}
+//#endregion
+export { i as ensureSession, o as fetchSession, a as prefetchSession, r as sessionOptions, s as useSession };

package/dist/queries/auth-query-options.d.ts

@@ -0,0 +1,14 @@
+import { CreateQueryOptions, DataTag, QueryKey } from '@tanstack/solid-query';
+import { BetterFetchError, BetterFetchOption } from 'better-auth/client';
+export type AuthQueryFn<TData = unknown> = (params: {
+    query?: Record<string, unknown>;
+    fetchOptions?: BetterFetchOption;
+}) => Promise<{
+    data: TData;
+}>;
+export type AuthQueryFnData<TFn> = TFn extends AuthQueryFn<infer TData> ? TData : never;
+export type AuthQueryKey<TFn extends AuthQueryFn = AuthQueryFn, TPrefix extends QueryKey = QueryKey> = readonly [...TPrefix, NonNullable<Parameters<TFn>[0]>["query"] | null];
+export type AuthQueryOptions<TFn extends AuthQueryFn = AuthQueryFn, TPrefix extends QueryKey = QueryKey> = Omit<CreateQueryOptions<AuthQueryFnData<TFn>, BetterFetchError, AuthQueryFnData<TFn>, AuthQueryKey<TFn, TPrefix>>, "queryKey"> & {
+    queryKey: DataTag<AuthQueryKey<TFn, TPrefix>, AuthQueryFnData<TFn>, BetterFetchError>;
+};
+export declare function authQueryOptions<TFn extends AuthQueryFn, const TPrefix extends QueryKey>(authFn: TFn, queryKey: TPrefix, params?: Parameters<TFn>[0]): AuthQueryOptions<TFn, TPrefix>;

package/dist/queries/auth-query-options.js

@@ -0,0 +1,17 @@
+import { queryOptions as e } from "@tanstack/solid-query";
+//#region src/queries/auth-query-options.ts
+function t(t, n, r) {
+	return e({
+		queryKey: [...n, r?.query ?? null],
+		queryFn: ({ signal: e }) => t({
+			...r,
+			fetchOptions: {
+				...r?.fetchOptions,
+				signal: e,
+				throw: !0
+			}
+		})
+	});
+}
+//#endregion
+export { t as authQueryOptions };

package/dist/queries/create-user-scoped-query.d.ts

@@ -0,0 +1,25 @@
+import { DataTag, QueryClient, QueryKey } from '@tanstack/solid-query';
+import { BetterFetchError } from 'better-auth/client';
+export type QueryMethod<TData = unknown> = (params?: any) => Promise<TData>;
+export type QueryParams<TMethod extends QueryMethod> = Parameters<TMethod>[0];
+export type QueryData<TMethod extends QueryMethod> = Awaited<ReturnType<TMethod>>;
+export declare function createUserScopedOptions<TMethod extends QueryMethod, const TQueryKey extends QueryKey>(queryKey: TQueryKey, authFn: TMethod, params?: QueryParams<TMethod>): (import('@tanstack/solid-query').QueryOptions<Awaited<ReturnType<TMethod>>, BetterFetchError, Awaited<ReturnType<TMethod>>, TQueryKey> & {
+    initialData?: undefined;
+} & {
+    queryKey: DataTag<TQueryKey, Awaited<ReturnType<TMethod>>, BetterFetchError>;
+}) & {
+    queryKey: DataTag<TQueryKey, Awaited<ReturnType<TMethod>>, BetterFetchError>;
+};
+export declare const ensureUserScopedQuery: <TMethod extends QueryMethod, const TQueryKey extends QueryKey>(queryClient: QueryClient, queryKey: TQueryKey, authFn: TMethod, params?: QueryParams<TMethod>) => Promise<unknown>;
+export declare const prefetchUserScopedQuery: <TMethod extends QueryMethod, const TQueryKey extends QueryKey>(queryClient: QueryClient, queryKey: TQueryKey, authFn: TMethod, params?: QueryParams<TMethod>) => Promise<void>;
+export declare const fetchUserScopedQuery: <TMethod extends QueryMethod, const TQueryKey extends QueryKey>(queryClient: QueryClient, queryKey: TQueryKey, authFn: TMethod, params?: QueryParams<TMethod>) => Promise<unknown>;
+export declare function createUserScopedQuery<TMethod extends QueryMethod, const TQueryKey extends QueryKey>(queryKey: () => TQueryKey, authFn: TMethod, params: () => QueryParams<TMethod> | undefined, canFetch: () => boolean, queryOptionsRest: () => Record<string, unknown>): import('@tanstack/solid-query').CreateQueryResult<Awaited<ReturnType<TMethod>>, BetterFetchError>;
+export declare const getSessionUserId: (session: {
+    data?: SessionLike;
+}) => string | undefined;
+type SessionLike = {
+    user?: {
+        id?: string;
+    };
+} | null | undefined;
+export {};

package/dist/queries/create-user-scoped-query.js

@@ -0,0 +1,29 @@
+import { createQuery as e, queryOptions as t, skipToken as n } from "@tanstack/solid-query";
+//#region src/queries/create-user-scoped-query.ts
+function r(e, n, r) {
+	return t({
+		queryKey: e,
+		queryFn: ({ signal: e }) => n({
+			...r ?? {},
+			fetchOptions: {
+				...r?.fetchOptions,
+				signal: e,
+				throw: !0
+			}
+		})
+	});
+}
+var i = (e, t, n, i) => e.ensureQueryData(r(t, n, i)), a = (e, t, n, i) => e.prefetchQuery(r(t, n, i)), o = (e, t, n, i) => e.fetchQuery(r(t, n, i));
+function s(t, i, a, o, s) {
+	return e(() => {
+		let e = r(t(), i, a());
+		return {
+			...s(),
+			...e,
+			queryFn: o() ? e.queryFn : n
+		};
+	});
+}
+var c = (e) => e.data?.user?.id;
+//#endregion
+export { r as createUserScopedOptions, s as createUserScopedQuery, i as ensureUserScopedQuery, o as fetchUserScopedQuery, c as getSessionUserId, a as prefetchUserScopedQuery };

package/dist/queries/multi-session/list-device-sessions-query.d.ts

@@ -0,0 +1,23 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { InferData, MultiSessionAuthClient } from '../../lib/auth-client';
+export type ListDeviceSessionsData<TAuthClient extends MultiSessionAuthClient> = InferData<TAuthClient["multiSession"]["listDeviceSessions"]>;
+export type ListDeviceSessionsParams<TAuthClient extends MultiSessionAuthClient> = Parameters<TAuthClient["multiSession"]["listDeviceSessions"]>[0];
+export type ListDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient> = Omit<ReturnType<typeof listDeviceSessionsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListDeviceSessionsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListDeviceSessions: <TAuthClient extends MultiSessionAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListDeviceSessionsParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListDeviceSessions: <TAuthClient extends MultiSessionAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListDeviceSessionsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListDeviceSessions: <TAuthClient extends MultiSessionAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListDeviceSessionsParams<TAuthClient>) => Promise<unknown>;
+export type UseListDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient> = ListDeviceSessionsOptions<TAuthClient> & ListDeviceSessionsParams<TAuthClient>;
+export declare function useListDeviceSessions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: UseListDeviceSessionsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/multi-session/list-device-sessions-query.js

@@ -0,0 +1,17 @@
+import { useSession as e } from "../auth/session-query.js";
+import { createUserScopedOptions as t, createUserScopedQuery as n, ensureUserScopedQuery as r, fetchUserScopedQuery as i, getSessionUserId as a, prefetchUserScopedQuery as o } from "../create-user-scoped-query.js";
+import { multiSessionQueryKeys as s } from "@better-auth-ui/core/plugins";
+//#region src/queries/multi-session/list-device-sessions-query.ts
+function c(e, n, r) {
+	return t(s.list(n, r?.query), e.multiSession.listDeviceSessions, r);
+}
+var l = (e, t, n, i) => r(e, s.list(n, i?.query), t.multiSession.listDeviceSessions, i), u = (e, t, n, r) => o(e, s.list(n, r?.query), t.multiSession.listDeviceSessions, r), d = (e, t, n, r) => i(e, s.list(n, r?.query), t.multiSession.listDeviceSessions, r);
+function f(t, r = {}) {
+	let i = e(t), o = () => a(i), { query: c, fetchOptions: l, ...u } = r;
+	return n(() => s.list(o(), c), t.multiSession.listDeviceSessions, () => ({
+		query: c,
+		fetchOptions: l
+	}), () => !!o(), () => u);
+}
+//#endregion
+export { l as ensureListDeviceSessions, d as fetchListDeviceSessions, c as listDeviceSessionsOptions, u as prefetchListDeviceSessions, f as useListDeviceSessions };

package/dist/queries/organization/active-organization-query.d.ts

@@ -0,0 +1,37 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { OrganizationAuthClient } from '../../lib/auth-client';
+import { FullOrganizationParams } from './full-organization-query';
+import { ListOrganizationsData } from './list-organizations-query';
+export type ActiveOrganizationData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = NonNullable<ListOrganizationsData<TAuthClient>> extends Array<infer TOrg> ? TOrg | null : unknown;
+export type ActiveOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = FullOrganizationParams<TAuthClient>;
+export type ActiveOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof activeOrganizationOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function activeOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "active", {
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+    membersLimit?: string | number | undefined;
+} | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureActiveOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchActiveOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>) => Promise<void>;
+export declare const fetchActiveOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>) => Promise<unknown>;
+export type UseActiveOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ActiveOrganizationOptions<TAuthClient> & ActiveOrganizationParams<TAuthClient>;
+export declare function useActiveOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseActiveOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/organization/active-organization-query.js

@@ -0,0 +1,26 @@
+import { useSession as e } from "../auth/session-query.js";
+import { useOrganizationSlug as t } from "./plugin.js";
+import { createOrganizationQueryOptions as n, ensureOrganizationQuery as r, fetchOrganizationQuery as i, prefetchOrganizationQuery as a, skipToken as o } from "./utils.js";
+import { createQuery as s } from "@tanstack/solid-query";
+import { organizationQueryKeys as c } from "@better-auth-ui/core/plugins";
+//#region src/queries/organization/active-organization-query.ts
+function l(e, t, r) {
+	return n(c.activeOrganization(t, r?.query), e.organization.getFullOrganization, r);
+}
+var u = (e, t, n, i) => r(e, c.activeOrganization(n, i?.query), t.organization.getFullOrganization, i), d = (e, t, n, r) => a(e, c.activeOrganization(n, r?.query), t.organization.getFullOrganization, r), f = (e, t, n, r) => i(e, c.activeOrganization(n, r?.query), t.organization.getFullOrganization, r);
+function p(n, r = {}) {
+	let i = e(n), a = t();
+	return s(() => {
+		let { query: e, fetchOptions: t, ...s } = r, c = i.data?.user.id, u = l(n, c, {
+			query: a ? { organizationSlug: a } : e,
+			fetchOptions: t
+		});
+		return {
+			...s,
+			...u,
+			queryFn: a === null ? async () => null : c ? u.queryFn : o
+		};
+	});
+}
+//#endregion
+export { l as activeOrganizationOptions, u as ensureActiveOrganization, f as fetchActiveOrganization, d as prefetchActiveOrganization, p as useActiveOrganization };

package/dist/queries/organization/full-organization-query.d.ts

@@ -0,0 +1,35 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { OrganizationAuthClient } from '../../lib/auth-client';
+export type FullOrganizationData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Awaited<ReturnType<TAuthClient["organization"]["getFullOrganization"]>>;
+export type FullOrganizationParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["getFullOrganization"]>[0];
+export type FullOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof fullOrganizationOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function fullOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+    membersLimit?: string | number | undefined;
+} | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureFullOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchFullOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>) => Promise<void>;
+export declare const fetchFullOrganization: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>) => Promise<unknown>;
+export type UseFullOrganizationOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = FullOrganizationOptions<TAuthClient> & FullOrganizationParams<TAuthClient>;
+export declare function useFullOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseFullOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/organization/full-organization-query.js

@@ -0,0 +1,25 @@
+import { useSession as e } from "../auth/session-query.js";
+import { createOrganizationQueryOptions as t, ensureOrganizationQuery as n, fetchOrganizationQuery as r, prefetchOrganizationQuery as i, skipToken as a } from "./utils.js";
+import { createQuery as o } from "@tanstack/solid-query";
+import { organizationQueryKeys as s } from "@better-auth-ui/core/plugins";
+//#region src/queries/organization/full-organization-query.ts
+function c(e, n, r) {
+	return t(s.fullDetail(n, r?.query), e.organization.getFullOrganization, r);
+}
+var l = (e, t, r, i) => n(e, s.fullDetail(r, i?.query), t.organization.getFullOrganization, i), u = (e, t, n, r) => i(e, s.fullDetail(n, r?.query), t.organization.getFullOrganization, r), d = (e, t, n, i) => r(e, s.fullDetail(n, i?.query), t.organization.getFullOrganization, i);
+function f(t, n = {}) {
+	let r = e(t);
+	return o(() => {
+		let { query: e, fetchOptions: i, ...o } = n, s = r.data?.user.id, l = c(t, s, {
+			query: e,
+			fetchOptions: i
+		});
+		return {
+			...o,
+			...l,
+			queryFn: s ? l.queryFn : a
+		};
+	});
+}
+//#endregion
+export { l as ensureFullOrganization, d as fetchFullOrganization, c as fullOrganizationOptions, u as prefetchFullOrganization, f as useFullOrganization };