@better-auth-ui/solid 1.6.19

package/dist/queries/organization/has-permission-query.d.ts

@@ -0,0 +1,23 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { OrganizationAuthClient } from '../../lib/auth-client';
+export type HasPermissionData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Awaited<ReturnType<TAuthClient["organization"]["hasPermission"]>>;
+export type HasPermissionParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["hasPermission"]>[0];
+export type HasPermissionOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof hasPermissionOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function hasPermissionOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "permissions", "has", Omit<HasPermissionParams<TAuthClient>, "fetchOptions"> | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "permissions", "has", Omit<HasPermissionParams<TAuthClient>, "fetchOptions"> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "permissions", "has", Omit<HasPermissionParams<TAuthClient>, "fetchOptions"> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureHasPermission: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchHasPermission: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>) => Promise<void>;
+export declare const fetchHasPermission: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>) => Promise<unknown>;
+export type UseHasPermissionOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = HasPermissionOptions<TAuthClient> & HasPermissionParams<TAuthClient>;
+export declare function useHasPermission<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options: UseHasPermissionOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/organization/has-permission-query.js

@@ -0,0 +1,31 @@
+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 { useActiveOrganization as o } from "./active-organization-query.js";
+import { createQuery as s } from "@tanstack/solid-query";
+import { organizationQueryKeys as c } from "@better-auth-ui/core/plugins";
+//#region src/queries/organization/has-permission-query.ts
+function l(e, n, r) {
+	let { fetchOptions: i, ...a } = r;
+	return t(c.permissions.has(n, a), e.organization.hasPermission, {
+		...a,
+		fetchOptions: i
+	});
+}
+var u = (e, t, r, i) => n(e, l(t, r, i).queryKey, t.organization.hasPermission, i), d = (e, t, n, r) => i(e, l(t, n, r).queryKey, t.organization.hasPermission, r), f = (e, t, n, i) => r(e, l(t, n, i).queryKey, t.organization.hasPermission, i);
+function p(t, n) {
+	let r = e(t), i = o(t, { enabled: !n.organizationId });
+	return s(() => {
+		let { fetchOptions: e, permissions: o, organizationId: s, ...c } = n, u = r.data?.user.id, d = s ?? i.data?.id, f = l(t, u, {
+			fetchOptions: e,
+			organizationId: d,
+			permissions: o
+		});
+		return {
+			...c,
+			...f,
+			queryFn: u && d ? f.queryFn : a
+		};
+	});
+}
+//#endregion
+export { u as ensureHasPermission, f as fetchHasPermission, l as hasPermissionOptions, d as prefetchHasPermission, p as useHasPermission };

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

@@ -0,0 +1,7 @@
+export * from './active-organization-query';
+export * from './full-organization-query';
+export * from './has-permission-query';
+export * from './list-invitations-query';
+export * from './list-members-query';
+export * from './list-organizations-query';
+export * from './list-user-invitations-query';

package/dist/queries/organization/index.js

@@ -0,0 +1,7 @@
+import "./active-organization-query.js";
+import "./full-organization-query.js";
+import "./has-permission-query.js";
+import "./list-invitations-query.js";
+import "./list-members-query.js";
+import "./list-organizations-query.js";
+import "./list-user-invitations-query.js";

package/dist/queries/organization/list-invitations-query.d.ts

@@ -0,0 +1,29 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { OrganizationAuthClient } from '../../lib/auth-client';
+export type ListOrganizationInvitationsData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Awaited<ReturnType<TAuthClient["organization"]["listInvitations"]>>;
+export type ListOrganizationInvitationsParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["listInvitations"]>[0];
+export type ListOrganizationInvitationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof listOrganizationInvitationsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listOrganizationInvitationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+    organizationId?: string | undefined;
+} | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+        organizationId?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+        organizationId?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListOrganizationInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListOrganizationInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListOrganizationInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>) => Promise<unknown>;
+export type UseListOrganizationInvitationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListOrganizationInvitationsOptions<TAuthClient> & ListOrganizationInvitationsParams<TAuthClient>;
+export declare function useListOrganizationInvitations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationInvitationsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/organization/list-invitations-query.js

@@ -0,0 +1,29 @@
+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 { useActiveOrganization as o } from "./active-organization-query.js";
+import { createQuery as s } from "@tanstack/solid-query";
+import { organizationQueryKeys as c } from "@better-auth-ui/core/plugins";
+//#region src/queries/organization/list-invitations-query.ts
+function l(e, n, r) {
+	return t(c.invitations.list(n, r?.query), e.organization.listInvitations, r);
+}
+var u = (e, t, r, i) => n(e, c.invitations.list(r, i?.query), t.organization.listInvitations, i), d = (e, t, n, r) => i(e, c.invitations.list(n, r?.query), t.organization.listInvitations, r), f = (e, t, n, i) => r(e, c.invitations.list(n, i?.query), t.organization.listInvitations, i);
+function p(t, n = {}) {
+	let r = e(t), { query: i, fetchOptions: c, ...u } = n, d = o(t, { enabled: !i?.organizationId });
+	return s(() => {
+		let e = r.data?.user.id, n = i?.organizationId ?? d.data?.id, o = l(t, e, {
+			query: {
+				...i,
+				organizationId: n
+			},
+			fetchOptions: c
+		});
+		return {
+			...u,
+			...o,
+			queryFn: e && n ? o.queryFn : a
+		};
+	});
+}
+//#endregion
+export { u as ensureListOrganizationInvitations, f as fetchListOrganizationInvitations, l as listOrganizationInvitationsOptions, d as prefetchListOrganizationInvitations, p as useListOrganizationInvitations };

package/dist/queries/organization/list-members-query.d.ts

@@ -0,0 +1,53 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { OrganizationAuthClient } from '../../lib/auth-client';
+export type ListOrganizationMembersData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Awaited<ReturnType<TAuthClient["organization"]["listMembers"]>>;
+export type ListOrganizationMembersParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["listMembers"]>[0];
+export type ListOrganizationMembersOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof listOrganizationMembersOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listOrganizationMembersOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+    limit?: string | number | undefined;
+    offset?: string | number | undefined;
+    sortBy?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+    filterField?: string | undefined;
+    filterValue?: string | number | boolean | string[] | number[] | undefined;
+    filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+} | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+        filterField?: string | undefined;
+        filterValue?: string | number | boolean | string[] | number[] | undefined;
+        filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+        filterField?: string | undefined;
+        filterValue?: string | number | boolean | string[] | number[] | undefined;
+        filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListOrganizationMembers: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListOrganizationMembers: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>) => Promise<void>;
+export declare const fetchListOrganizationMembers: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>) => Promise<unknown>;
+export type UseListOrganizationMembersOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListOrganizationMembersOptions<TAuthClient> & ListOrganizationMembersParams<TAuthClient>;
+export declare function useListOrganizationMembers<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationMembersOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/organization/list-members-query.js

@@ -0,0 +1,29 @@
+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 { useActiveOrganization as o } from "./active-organization-query.js";
+import { createQuery as s } from "@tanstack/solid-query";
+import { organizationQueryKeys as c } from "@better-auth-ui/core/plugins";
+//#region src/queries/organization/list-members-query.ts
+function l(e, n, r) {
+	return t(c.members.list(n, r?.query), e.organization.listMembers, r);
+}
+var u = (e, t, r, i) => n(e, c.members.list(r, i?.query), t.organization.listMembers, i), d = (e, t, n, r) => i(e, c.members.list(n, r?.query), t.organization.listMembers, r), f = (e, t, n, i) => r(e, c.members.list(n, i?.query), t.organization.listMembers, i);
+function p(t, n = {}) {
+	let r = e(t), i = o(t, { enabled: !n.query?.organizationId });
+	return s(() => {
+		let { query: e, fetchOptions: o, ...s } = n, c = r.data?.user.id, u = e?.organizationId ?? i.data?.id, d = l(t, c, {
+			query: {
+				...e,
+				organizationId: u
+			},
+			fetchOptions: o
+		});
+		return {
+			...s,
+			...d,
+			queryFn: c && u ? d.queryFn : a
+		};
+	});
+}
+//#endregion
+export { u as ensureListOrganizationMembers, f as fetchListOrganizationMembers, l as listOrganizationMembersOptions, d as prefetchListOrganizationMembers, p as useListOrganizationMembers };

package/dist/queries/organization/list-organizations-query.d.ts

@@ -0,0 +1,23 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { OrganizationAuthClient } from '../../lib/auth-client';
+export type ListOrganizationsData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Awaited<ReturnType<TAuthClient["organization"]["list"]>>;
+export type ListOrganizationsParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["list"]>[0];
+export type ListOrganizationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof listOrganizationsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listOrganizationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListOrganizations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationsParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListOrganizations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListOrganizations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationsParams<TAuthClient>) => Promise<unknown>;
+export type UseListOrganizationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListOrganizationsOptions<TAuthClient> & ListOrganizationsParams<TAuthClient>;
+export declare function useListOrganizations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/organization/list-organizations-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/list-organizations-query.ts
+function c(e, n, r) {
+	return t(s.list(n, r?.query), e.organization.list, r);
+}
+var l = (e, t, r, i) => n(e, s.list(r, i?.query), t.organization.list, i), u = (e, t, n, r) => i(e, s.list(n, r?.query), t.organization.list, r), d = (e, t, n, i) => r(e, s.list(n, i?.query), t.organization.list, 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 ensureListOrganizations, d as fetchListOrganizations, c as listOrganizationsOptions, u as prefetchListOrganizations, f as useListOrganizations };

package/dist/queries/organization/list-user-invitations-query.d.ts

@@ -0,0 +1,29 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { OrganizationAuthClient } from '../../lib/auth-client';
+export type ListUserInvitationsData<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Awaited<ReturnType<TAuthClient["organization"]["listUserInvitations"]>>;
+export type ListUserInvitationsParams<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Parameters<TAuthClient["organization"]["listUserInvitations"]>[0];
+export type ListUserInvitationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = Omit<ReturnType<typeof listUserInvitationsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listUserInvitationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+    email?: string | undefined;
+} | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+        email?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
+        email?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListUserInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListUserInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListUserInvitations: <TAuthClient extends OrganizationAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>) => Promise<unknown>;
+export type UseListUserInvitationsOptions<TAuthClient extends OrganizationAuthClient = OrganizationAuthClient> = ListUserInvitationsOptions<TAuthClient> & ListUserInvitationsParams<TAuthClient>;
+export declare function useListUserInvitations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListUserInvitationsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/organization/list-user-invitations-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/list-user-invitations-query.ts
+function c(e, n, r) {
+	return t(s.userInvitations.list(n, r?.query), e.organization.listUserInvitations, r);
+}
+var l = (e, t, r, i) => n(e, s.userInvitations.list(r, i?.query), t.organization.listUserInvitations, i), u = (e, t, n, r) => i(e, s.userInvitations.list(n, r?.query), t.organization.listUserInvitations, r), d = (e, t, n, i) => r(e, s.userInvitations.list(n, i?.query), t.organization.listUserInvitations, i);
+function f(t, n = {}) {
+	let r = e(t), { query: i, fetchOptions: s, ...l } = n;
+	return o(() => {
+		let e = r.data?.user.id, n = c(t, e, {
+			query: i,
+			fetchOptions: s
+		});
+		return {
+			...l,
+			...n,
+			queryFn: e ? n.queryFn : a
+		};
+	});
+}
+//#endregion
+export { l as ensureListUserInvitations, d as fetchListUserInvitations, c as listUserInvitationsOptions, u as prefetchListUserInvitations, f as useListUserInvitations };

package/dist/queries/organization/plugin.d.ts

@@ -0,0 +1 @@
+export declare function useOrganizationSlug(): string | null | undefined;

package/dist/queries/organization/plugin.js

@@ -0,0 +1,8 @@
+import { useAuth as e } from "../../lib/auth-provider.js";
+import { organizationPlugin as t } from "@better-auth-ui/core/plugins";
+//#region src/queries/organization/plugin.ts
+function n() {
+	return e().plugins?.find((e) => e.id === t.id)?.slug;
+}
+//#endregion
+export { n as useOrganizationSlug };

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

@@ -0,0 +1,16 @@
+import { DataTag, QueryClient, QueryKey, skipToken } from '@tanstack/solid-query';
+import { BetterFetchError } from 'better-auth/client';
+export type OrganizationQueryMethod<TData = unknown> = (params?: any) => Promise<TData>;
+export type OrganizationQueryParams<TMethod extends OrganizationQueryMethod> = Parameters<TMethod>[0];
+export type OrganizationQueryData<TMethod extends OrganizationQueryMethod> = Awaited<ReturnType<TMethod>>;
+export declare function createOrganizationQueryOptions<TMethod extends OrganizationQueryMethod, const TQueryKey extends QueryKey>(queryKey: TQueryKey, authFn: TMethod, params?: OrganizationQueryParams<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 ensureOrganizationQuery: <TMethod extends OrganizationQueryMethod, const TQueryKey extends QueryKey>(queryClient: QueryClient, queryKey: TQueryKey, authFn: TMethod, params?: OrganizationQueryParams<TMethod>) => Promise<unknown>;
+export declare const prefetchOrganizationQuery: <TMethod extends OrganizationQueryMethod, const TQueryKey extends QueryKey>(queryClient: QueryClient, queryKey: TQueryKey, authFn: TMethod, params?: OrganizationQueryParams<TMethod>) => Promise<void>;
+export declare const fetchOrganizationQuery: <TMethod extends OrganizationQueryMethod, const TQueryKey extends QueryKey>(queryClient: QueryClient, queryKey: TQueryKey, authFn: TMethod, params?: OrganizationQueryParams<TMethod>) => Promise<unknown>;
+export { skipToken };

package/dist/queries/organization/utils.js

@@ -0,0 +1,18 @@
+import { queryOptions as e, skipToken as t } from "@tanstack/solid-query";
+//#region src/queries/organization/utils.ts
+function n(t, n, r) {
+	return e({
+		queryKey: t,
+		queryFn: ({ signal: e }) => n({
+			...r ?? {},
+			fetchOptions: {
+				...r?.fetchOptions,
+				signal: e,
+				throw: !0
+			}
+		})
+	});
+}
+var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
+//#endregion
+export { n as createOrganizationQueryOptions, r as ensureOrganizationQuery, a as fetchOrganizationQuery, i as prefetchOrganizationQuery, t as skipToken };

package/dist/queries/passkey/list-passkeys-query.d.ts

@@ -0,0 +1,23 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { InferData, PasskeyAuthClient } from '../../lib/auth-client';
+export type ListPasskeysData<TAuthClient extends PasskeyAuthClient> = InferData<TAuthClient["passkey"]["listUserPasskeys"]>;
+export type ListPasskeysParams<TAuthClient extends PasskeyAuthClient> = Parameters<TAuthClient["passkey"]["listUserPasskeys"]>[0];
+export type ListPasskeysOptions<TAuthClient extends PasskeyAuthClient> = Omit<ReturnType<typeof listPasskeysOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listPasskeysOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListPasskeysParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListPasskeys: <TAuthClient extends PasskeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListPasskeysParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListPasskeys: <TAuthClient extends PasskeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListPasskeysParams<TAuthClient>) => Promise<void>;
+export declare const fetchListPasskeys: <TAuthClient extends PasskeyAuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListPasskeysParams<TAuthClient>) => Promise<unknown>;
+export type UseListPasskeysOptions<TAuthClient extends PasskeyAuthClient> = ListPasskeysOptions<TAuthClient> & ListPasskeysParams<TAuthClient>;
+export declare function useListPasskeys<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: UseListPasskeysOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/passkey/list-passkeys-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 { passkeyQueryKeys as s } from "@better-auth-ui/core/plugins";
+//#region src/queries/passkey/list-passkeys-query.ts
+function c(e, n, r) {
+	return t(s.list(n, r?.query), e.passkey.listUserPasskeys, r);
+}
+var l = (e, t, n, i) => r(e, s.list(n, i?.query), t.passkey.listUserPasskeys, i), u = (e, t, n, r) => o(e, s.list(n, r?.query), t.passkey.listUserPasskeys, r), d = (e, t, n, r) => i(e, s.list(n, r?.query), t.passkey.listUserPasskeys, 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.passkey.listUserPasskeys, () => ({
+		query: c,
+		fetchOptions: l
+	}), () => !!o(), () => u);
+}
+//#endregion
+export { l as ensureListPasskeys, d as fetchListPasskeys, c as listPasskeysOptions, u as prefetchListPasskeys, f as useListPasskeys };

package/dist/queries/settings/account-info-query.d.ts

@@ -0,0 +1,35 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { AuthClient, InferData } from '../../lib/auth-client';
+export type AccountInfoData<TAuthClient extends AuthClient> = InferData<TAuthClient["accountInfo"]>;
+export type AccountInfoParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["accountInfo"]>[0];
+export type AccountInfoOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof accountInfoOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function accountInfoOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: AccountInfoParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "accountInfo", {
+    accountId?: string | undefined;
+    providerId?: string | undefined;
+    userId?: string | undefined;
+} | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "accountInfo", {
+        accountId?: string | undefined;
+        providerId?: string | undefined;
+        userId?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "accountInfo", {
+        accountId?: string | undefined;
+        providerId?: string | undefined;
+        userId?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureAccountInfo: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: AccountInfoParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchAccountInfo: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: AccountInfoParams<TAuthClient>) => Promise<void>;
+export declare const fetchAccountInfo: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: AccountInfoParams<TAuthClient>) => Promise<unknown>;
+export type UseAccountInfoOptions<TAuthClient extends AuthClient> = AccountInfoOptions<TAuthClient> & AccountInfoParams<TAuthClient>;
+export declare function useAccountInfo<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseAccountInfoOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/settings/account-info-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 { authQueryKeys as s } from "@better-auth-ui/core";
+//#region src/queries/settings/account-info-query.ts
+function c(e, n, r) {
+	return t(s.accountInfo(n, r?.query), e.accountInfo, r);
+}
+var l = (e, t, n, i) => r(e, s.accountInfo(n, i?.query), t.accountInfo, i), u = (e, t, n, r) => o(e, s.accountInfo(n, r?.query), t.accountInfo, r), d = (e, t, n, r) => i(e, s.accountInfo(n, r?.query), t.accountInfo, r);
+function f(t, r = {}) {
+	let i = e(t), o = () => a(i), { query: c, fetchOptions: l, ...u } = r;
+	return n(() => s.accountInfo(o(), c), t.accountInfo, () => ({
+		query: c,
+		fetchOptions: l
+	}), () => !!(o() && c?.accountId), () => u);
+}
+//#endregion
+export { c as accountInfoOptions, l as ensureAccountInfo, d as fetchAccountInfo, u as prefetchAccountInfo, f as useAccountInfo };

package/dist/queries/settings/list-accounts-query.d.ts

@@ -0,0 +1,23 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { AuthClient, InferData } from '../../lib/auth-client';
+export type ListAccountsData<TAuthClient extends AuthClient> = InferData<TAuthClient["listAccounts"]>;
+export type ListAccountsParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["listAccounts"]>[0];
+export type ListAccountsOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof listAccountsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listAccountsOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListAccountsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "listAccounts", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListAccounts: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListAccountsParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListAccounts: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListAccountsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListAccounts: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListAccountsParams<TAuthClient>) => Promise<unknown>;
+export type UseListAccountsOptions<TAuthClient extends AuthClient> = ListAccountsOptions<TAuthClient> & ListAccountsParams<TAuthClient>;
+export declare function useListAccounts<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListAccountsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/settings/list-accounts-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 { authQueryKeys as s } from "@better-auth-ui/core";
+//#region src/queries/settings/list-accounts-query.ts
+function c(e, n, r) {
+	return t(s.listAccounts(n, r?.query), e.listAccounts, r);
+}
+var l = (e, t, n, i) => r(e, s.listAccounts(n, i?.query), t.listAccounts, i), u = (e, t, n, r) => o(e, s.listAccounts(n, r?.query), t.listAccounts, r), d = (e, t, n, r) => i(e, s.listAccounts(n, r?.query), t.listAccounts, r);
+function f(t, r = {}) {
+	let i = e(t), o = () => a(i), { query: c, fetchOptions: l, ...u } = r;
+	return n(() => s.listAccounts(o(), c), t.listAccounts, () => ({
+		query: c,
+		fetchOptions: l
+	}), () => !!o(), () => u);
+}
+//#endregion
+export { l as ensureListAccounts, d as fetchListAccounts, c as listAccountsOptions, u as prefetchListAccounts, f as useListAccounts };

package/dist/queries/settings/list-sessions-query.d.ts

@@ -0,0 +1,24 @@
+import { QueryClient } from '@tanstack/solid-query';
+import { AuthClient, InferData } from '../../lib/auth-client';
+export type ListSessionsData<TAuthClient extends AuthClient> = InferData<TAuthClient["listSessions"]>;
+export type ListSessionsParams<TAuthClient extends AuthClient> = Parameters<TAuthClient["listSessions"]>[0];
+export type ListSession<TAuthClient extends AuthClient = AuthClient> = NonNullable<ListSessionsData<TAuthClient>>[number];
+export type ListSessionsOptions<TAuthClient extends AuthClient> = Omit<ReturnType<typeof listSessionsOptions<TAuthClient>>, "queryKey" | "queryFn">;
+export declare function listSessionsOptions<TAuthClient extends AuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListSessionsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('better-auth/solid').BetterFetchError, any, readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "listSessions", Record<string, any> | null] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+    };
+};
+export declare const ensureListSessions: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListSessionsParams<TAuthClient>) => Promise<unknown>;
+export declare const prefetchListSessions: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListSessionsParams<TAuthClient>) => Promise<void>;
+export declare const fetchListSessions: <TAuthClient extends AuthClient>(queryClient: QueryClient, authClient: TAuthClient, userId: string, params?: ListSessionsParams<TAuthClient>) => Promise<unknown>;
+export type UseListSessionsOptions<TAuthClient extends AuthClient> = ListSessionsOptions<TAuthClient> & ListSessionsParams<TAuthClient>;
+export declare function useListSessions<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UseListSessionsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('better-auth/solid').BetterFetchError>;

package/dist/queries/settings/list-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 { authQueryKeys as s } from "@better-auth-ui/core";
+//#region src/queries/settings/list-sessions-query.ts
+function c(e, n, r) {
+	return t(s.listSessions(n, r?.query), e.listSessions, r);
+}
+var l = (e, t, n, i) => r(e, s.listSessions(n, i?.query), t.listSessions, i), u = (e, t, n, r) => o(e, s.listSessions(n, r?.query), t.listSessions, r), d = (e, t, n, r) => i(e, s.listSessions(n, r?.query), t.listSessions, r);
+function f(t, r = {}) {
+	let i = e(t), o = () => a(i), { query: c, fetchOptions: l, ...u } = r;
+	return n(() => s.listSessions(o(), c), t.listSessions, () => ({
+		query: c,
+		fetchOptions: l
+	}), () => !!o(), () => u);
+}
+//#endregion
+export { l as ensureListSessions, d as fetchListSessions, c as listSessionsOptions, u as prefetchListSessions, f as useListSessions };

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

@@ -0,0 +1,19 @@
+import { DataTag, QueryClient } from '@tanstack/solid-query';
+import { APIError } from 'better-auth';
+import { AuthServer } from '../../../lib/auth-server';
+export type SessionData<TAuth extends AuthServer = AuthServer> = Awaited<ReturnType<TAuth["api"]["getSession"]>>;
+export type Session<TAuth extends AuthServer = AuthServer> = NonNullable<SessionData<TAuth>>;
+export type SessionParams<TAuth extends AuthServer> = Parameters<TAuth["api"]["getSession"]>[0];
+export declare function sessionOptions<TAuth extends AuthServer>(auth: TAuth, params: SessionParams<TAuth>): (import('@tanstack/solid-query').QueryOptions<Awaited<ReturnType<TAuth["api"]["getSession"]>>, APIError, Awaited<ReturnType<TAuth["api"]["getSession"]>>, readonly ["auth", "getSession"]> & {
+    initialData?: undefined;
+} & {
+    queryKey: readonly ["auth", "getSession"] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["getSession"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "getSession"], Awaited<ReturnType<TAuth["api"]["getSession"]>>, APIError>;
+};
+export declare const ensureSession: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, params: SessionParams<TAuth>) => Promise<unknown>;
+export declare const prefetchSession: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, params: SessionParams<TAuth>) => Promise<void>;
+export declare const fetchSession: <TAuth extends AuthServer>(queryClient: QueryClient, auth: TAuth, params: SessionParams<TAuth>) => Promise<unknown>;

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

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