@better-auth-ui/solid 1.6.22 → 1.6.24

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

@@ -3,7 +3,7 @@ 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<{
+export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<{
     data: null;
     error: {
         message?: string | undefined;
@@ -15,8 +15,8 @@ export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>
     error: null;
 } | {
     webauthn: {
-        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
-        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+        response: import('@simplewebauthn/server').RegistrationResponseJSON;
+        clientExtensionResults: import('@simplewebauthn/server').AuthenticationExtensionsClientOutputs;
     };
     data: import('@better-auth/passkey').Passkey;
     error: null;
@@ -28,12 +28,12 @@ export declare function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>
         status: number;
         statusText: string;
     };
-}, import('better-auth/solid').BetterFetchError, {
+}, import('@better-fetch/fetch').BetterFetchError, {
     fetchOptions?: import('better-auth').ClientFetchOption;
     name?: string;
     authenticatorAttachment?: "platform" | "cross-platform";
     context?: string | null;
-    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+    extensions?: import('@simplewebauthn/server').AuthenticationExtensionsClientInputs;
     useAutoRegister?: boolean;
     returnWebAuthnResponse?: boolean;
 } | undefined, unknown>, "mutationKey">;
@@ -49,8 +49,8 @@ export declare function useAddPasskey<TAuthClient extends PasskeyAuthClient>(aut
     error: null;
 } | {
     webauthn: {
-        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
-        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+        response: import('@simplewebauthn/server').RegistrationResponseJSON;
+        clientExtensionResults: import('@simplewebauthn/server').AuthenticationExtensionsClientOutputs;
     };
     data: import('@better-auth/passkey').Passkey;
     error: null;
@@ -62,12 +62,12 @@ export declare function useAddPasskey<TAuthClient extends PasskeyAuthClient>(aut
         status: number;
         statusText: string;
     };
-}, import('better-auth/solid').BetterFetchError, {
+}, import('@better-fetch/fetch').BetterFetchError, {
     fetchOptions?: import('better-auth').ClientFetchOption;
     name?: string;
     authenticatorAttachment?: "platform" | "cross-platform";
     context?: string | null;
-    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+    extensions?: import('@simplewebauthn/server').AuthenticationExtensionsClientInputs;
     useAutoRegister?: boolean;
     returnWebAuthnResponse?: boolean;
 } | undefined, unknown>;

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

@@ -3,14 +3,14 @@ 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<{
+export declare function deletePasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').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<{
+export declare function useDeletePasskey<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: DeletePasskeyOptions): import('@tanstack/solid-query').CreateMutationResult<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     id: string;
 } & {
     fetchOptions?: import('better-auth').ClientFetchOption<Partial<{

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

@@ -1,6 +1,6 @@
 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<{
+export declare function signInPasskeyOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<{
     data: null;
     error: {
         message?: string | undefined;
@@ -23,8 +23,8 @@ export declare function signInPasskeyOptions<TAuthClient extends PasskeyAuthClie
     };
 } | {
     webauthn: {
-        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
-        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+        response: import('@simplewebauthn/server').AuthenticationResponseJSON;
+        clientExtensionResults: import('@simplewebauthn/server').AuthenticationExtensionsClientOutputs;
     };
     data: null;
     error: {
@@ -34,17 +34,17 @@ export declare function signInPasskeyOptions<TAuthClient extends PasskeyAuthClie
     };
 } | {
     webauthn: {
-        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
-        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+        response: import('@simplewebauthn/server').AuthenticationResponseJSON;
+        clientExtensionResults: import('@simplewebauthn/server').AuthenticationExtensionsClientOutputs;
     };
     data: {
         session: import('better-auth').Session;
         user: import('better-auth').User;
     };
     error: null;
-}, import('better-auth/solid').BetterFetchError, {
+}, import('@better-fetch/fetch').BetterFetchError, {
     autoFill?: boolean;
-    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+    extensions?: import('@simplewebauthn/server').AuthenticationExtensionsClientInputs;
     returnWebAuthnResponse?: boolean;
     fetchOptions?: import('better-auth').ClientFetchOption;
 } | undefined, unknown>, "mutationKey">;

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

@@ -1,6 +1,6 @@
 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<{
+export declare function changeEmailOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     newEmail: string;
     callbackURL?: string | undefined;
 } & {

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

@@ -1,6 +1,6 @@
 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<{
+export declare function changePasswordOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     newPassword: string;
     currentPassword: string;
     revokeOtherSessions?: boolean | undefined;

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

@@ -1,6 +1,6 @@
 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<{
+export declare function deleteUserOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     callbackURL?: string | undefined;
     password?: string | undefined;
     token?: string | undefined;

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

@@ -1,6 +1,6 @@
 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<{
+export declare function linkSocialOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     provider: unknown;
     callbackURL?: string | undefined;
     idToken?: {

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

@@ -3,14 +3,14 @@ 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<{
+export declare function revokeSessionOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').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<{
+export declare function useRevokeSession<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: RevokeSessionOptions): import('@tanstack/solid-query').CreateMutationResult<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     token: string;
 } & {
     fetchOptions?: import('better-auth').ClientFetchOption<Partial<{

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

@@ -3,7 +3,7 @@ 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<{
+export declare function unlinkAccountOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     providerId: string;
     accountId?: string | undefined;
 } & {
@@ -12,7 +12,7 @@ export declare function unlinkAccountOptions<TAuthClient extends AuthClient>(aut
         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<{
+export declare function useUnlinkAccount<TAuthClient extends AuthClient>(authClient: TAuthClient, options?: UnlinkAccountOptions): import('@tanstack/solid-query').CreateMutationResult<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     providerId: string;
     accountId?: string | undefined;
 } & {

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

@@ -1,6 +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<{}> & {
+export declare function updateUserOptions<TAuthClient extends AuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').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/username/is-username-available-mutation.d.ts

@@ -1,6 +1,6 @@
 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<{
+export declare function isUsernameAvailableOptions<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     username: string;
 } & {
     fetchOptions?: import('better-auth').ClientFetchOption<Partial<{

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

@@ -1,6 +1,6 @@
 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<{
+export declare function signInUsernameOptions<TAuthClient extends UsernameAuthClient>(authClient: TAuthClient): import('@tanstack/query-core').WithRequired<import('@tanstack/solid-query').MutationOptions<any, import('@better-fetch/fetch').BetterFetchError, import('better-auth').Prettify<{
     username: string;
     password: string;
     rememberMe?: boolean | undefined;

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

@@ -3,7 +3,7 @@ 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", {
+export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListApiKeysParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').BetterFetchError, any, readonly ["auth", "user", string | undefined, "apiKey", "list", {
     configId?: string | undefined;
     organizationId?: string | undefined;
     limit?: unknown;
@@ -22,7 +22,7 @@ export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>
         sortDirection?: "asc" | "desc" | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "apiKey", "list", {
@@ -34,11 +34,11 @@ export declare function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>
         sortDirection?: "asc" | "desc" | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useListApiKeys<TAuthClient extends ApiKeyAuthClient>(authClient: TAuthClient, options?: UseListApiKeysOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -3,21 +3,21 @@ 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]> & {
+export declare function listDeviceSessionsOptions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListDeviceSessionsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').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;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useListDeviceSessions<TAuthClient extends MultiSessionAuthClient>(authClient: TAuthClient, options?: UseListDeviceSessionsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -5,7 +5,7 @@ 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", {
+export declare function activeOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ActiveOrganizationParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "active", {
     organizationId?: string | undefined;
     organizationSlug?: string | undefined;
     membersLimit?: string | number | undefined;
@@ -18,7 +18,7 @@ export declare function activeOrganizationOptions<TAuthClient extends Organizati
         membersLimit?: string | number | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "organization", "active", {
@@ -27,11 +27,11 @@ export declare function activeOrganizationOptions<TAuthClient extends Organizati
         membersLimit?: string | number | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useActiveOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseActiveOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -3,7 +3,7 @@ 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", {
+export declare function fullOrganizationOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: FullOrganizationParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
     organizationId?: string | undefined;
     organizationSlug?: string | undefined;
     membersLimit?: string | number | undefined;
@@ -16,7 +16,7 @@ export declare function fullOrganizationOptions<TAuthClient extends Organization
         membersLimit?: string | number | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
@@ -25,11 +25,11 @@ export declare function fullOrganizationOptions<TAuthClient extends Organization
         membersLimit?: string | number | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useFullOrganization<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseFullOrganizationOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -3,21 +3,21 @@ 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]> & {
+export declare function hasPermissionOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params: HasPermissionParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').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;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "organization", "permissions", "has", Omit<HasPermissionParams<TAuthClient>, "fetchOptions"> | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useHasPermission<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options: UseHasPermissionOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -3,7 +3,7 @@ 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", {
+export declare function listOrganizationInvitationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationInvitationsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
     organizationId?: string | undefined;
 } | null]> & {
     initialData?: undefined;
@@ -12,18 +12,18 @@ export declare function listOrganizationInvitationsOptions<TAuthClient extends O
         organizationId?: string | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
         organizationId?: string | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useListOrganizationInvitations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationInvitationsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -3,7 +3,7 @@ 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", {
+export declare function listOrganizationMembersOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationMembersParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "members", "list", {
     limit?: string | number | undefined;
     offset?: string | number | undefined;
     sortBy?: string | undefined;
@@ -28,7 +28,7 @@ export declare function listOrganizationMembersOptions<TAuthClient extends Organ
         organizationSlug?: string | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "organization", "members", "list", {
@@ -43,11 +43,11 @@ export declare function listOrganizationMembersOptions<TAuthClient extends Organ
         organizationSlug?: string | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useListOrganizationMembers<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationMembersOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -3,21 +3,21 @@ 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]> & {
+export declare function listOrganizationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListOrganizationsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').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;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "organization", "list", Record<string, any> | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useListOrganizations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListOrganizationsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -3,7 +3,7 @@ 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", {
+export declare function listUserInvitationsOptions<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListUserInvitationsParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').BetterFetchError, any, readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
     email?: string | undefined;
 } | null]> & {
     initialData?: undefined;
@@ -12,18 +12,18 @@ export declare function listUserInvitationsOptions<TAuthClient extends Organizat
         email?: string | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "organization", "userInvitations", "list", {
         email?: string | undefined;
     } | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useListUserInvitations<TAuthClient extends OrganizationAuthClient>(authClient: TAuthClient, options?: UseListUserInvitationsOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;

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

@@ -3,21 +3,21 @@ 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]> & {
+export declare function listPasskeysOptions<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, userId: string | undefined, params?: ListPasskeysParams<TAuthClient>): import('@tanstack/solid-query').QueryOptions<any, import('@better-fetch/fetch').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;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').BetterFetchError;
     };
 } & {
     queryKey: readonly ["auth", "user", string | undefined, "passkey", "list", Record<string, any> | null] & {
         [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: import('better-auth/solid').BetterFetchError;
+        [dataTagErrorSymbol]: import('@better-fetch/fetch').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>;
+export declare function useListPasskeys<TAuthClient extends PasskeyAuthClient>(authClient: TAuthClient, options?: UseListPasskeysOptions<TAuthClient>): import('@tanstack/solid-query').CreateQueryResult<any, import('@better-fetch/fetch').BetterFetchError>;