@better-auth-ui/react 1.6.0 → 1.6.2

package/dist/hooks/auth/use-sign-up-email.d.ts

@@ -1,6 +1,5 @@
-import { type AuthClient } from "@better-auth-ui/react";
-import type { UseAuthMutationOptions } from "./use-auth-mutation";
-export { useAuthMutation } from "./use-auth-mutation";
+import { AuthClient } from '../../lib/auth-client';
+import { UseAuthMutationOptions } from './use-auth-mutation';
 /**
  * Hook that creates a mutation for email/password sign-up.
  *
@@ -9,32 +8,32 @@ export { useAuthMutation } from "./use-auth-mutation";
  *
  * @returns The `useMutation` result.
  */
-export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClient["signUp"]["email"]>): import("./use-auth-mutation").UseAuthMutationResult<(<FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClient["signUp"]["email"]>): import('./use-auth-mutation').UseAuthMutationResult<(<FetchOptions extends import('better-auth').ClientFetchOption<Partial<{
     name: string;
     email: string;
     password: string;
     image?: string | undefined;
     callbackURL?: string | undefined;
     rememberMe?: boolean | undefined;
-}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<import("better-auth/client").InferSignUpEmailCtx<{
+}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import('better-auth').Prettify<import('better-auth/client').InferSignUpEmailCtx<{
     plugins: ({
         id: "magic-link";
         version: string;
-        $InferServerPlugin: ReturnType<(options: import("better-auth/plugins/magic-link").MagicLinkOptions) => {
+        $InferServerPlugin: ReturnType<(options: import('better-auth/plugins/magic-link').MagicLinkOptions) => {
             id: "magic-link";
             version: string;
             endpoints: {
-                signInMagicLink: import("better-auth").StrictEndpoint<"/sign-in/magic-link", {
+                signInMagicLink: import('better-auth').StrictEndpoint<"/sign-in/magic-link", {
                     method: "POST";
                     requireHeaders: true;
-                    body: import("zod").ZodObject<{
-                        email: import("zod").ZodEmail;
-                        name: import("zod").ZodOptional<import("zod").ZodString>;
-                        callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
-                        newUserCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
-                        errorCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
-                        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
-                    }, import("zod/v4/core").$strip>;
+                    body: import('zod').ZodObject<{
+                        email: import('zod').ZodEmail;
+                        name: import('zod').ZodOptional<import('zod').ZodString>;
+                        callbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                        newUserCallbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                        errorCallbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                        metadata: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodAny>>;
+                    }, import('zod/v4/core').$strip>;
                     metadata: {
                         openapi: {
                             operationId: string;
@@ -61,15 +60,15 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                 }, {
                     status: boolean;
                 }>;
-                magicLinkVerify: import("better-auth").StrictEndpoint<"/magic-link/verify", {
+                magicLinkVerify: import('better-auth').StrictEndpoint<"/magic-link/verify", {
                     method: "GET";
-                    query: import("zod").ZodObject<{
-                        token: import("zod").ZodString;
-                        callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
-                        errorCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
-                        newUserCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
-                    }, import("zod/v4/core").$strip>;
-                    use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>)[];
+                    query: import('zod').ZodObject<{
+                        token: import('zod').ZodString;
+                        callbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                        errorCallbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                        newUserCallbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                    }, import('zod/v4/core').$strip>;
+                    use: ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<void>)[];
                     requireHeaders: true;
                     metadata: {
                         openapi: {
@@ -125,16 +124,16 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                 window: number;
                 max: number;
             }[];
-            options: import("better-auth/plugins/magic-link").MagicLinkOptions;
+            options: import('better-auth/plugins/magic-link').MagicLinkOptions;
         }>;
     } | {
         id: "multi-session";
         version: string;
-        $InferServerPlugin: ReturnType<(options?: import("better-auth/plugins/multi-session").MultiSessionConfig | undefined) => {
+        $InferServerPlugin: ReturnType<(options?: import('better-auth/plugins/multi-session').MultiSessionConfig | undefined) => {
             id: "multi-session";
             version: string;
             endpoints: {
-                listDeviceSessions: import("better-auth").StrictEndpoint<"/multi-session/list-device-sessions", {
+                listDeviceSessions: import('better-auth').StrictEndpoint<"/multi-session/list-device-sessions", {
                     method: "GET";
                     requireHeaders: true;
                 }, {
@@ -158,11 +157,11 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                         image?: string | null | undefined;
                     };
                 }[]>;
-                setActiveSession: import("better-auth").StrictEndpoint<"/multi-session/set-active", {
+                setActiveSession: import('better-auth').StrictEndpoint<"/multi-session/set-active", {
                     method: "POST";
-                    body: import("zod").ZodObject<{
-                        sessionToken: import("zod").ZodString;
-                    }, import("zod/v4/core").$strip>;
+                    body: import('zod').ZodObject<{
+                        sessionToken: import('zod').ZodString;
+                    }, import('zod/v4/core').$strip>;
                     requireHeaders: true;
                     metadata: {
                         openapi: {
@@ -207,13 +206,13 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                         image?: string | null | undefined;
                     } & Record<string, any>;
                 }>;
-                revokeDeviceSession: import("better-auth").StrictEndpoint<"/multi-session/revoke", {
+                revokeDeviceSession: import('better-auth').StrictEndpoint<"/multi-session/revoke", {
                     method: "POST";
-                    body: import("zod").ZodObject<{
-                        sessionToken: import("zod").ZodString;
-                    }, import("zod/v4/core").$strip>;
+                    body: import('zod').ZodObject<{
+                        sessionToken: import('zod').ZodString;
+                    }, import('zod/v4/core').$strip>;
                     requireHeaders: true;
-                    use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    use: ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
                         session: {
                             session: Record<string, any> & {
                                 id: string;
@@ -264,13 +263,13 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
             };
             hooks: {
                 after: {
-                    matcher: (context: import("better-auth").HookEndpointContext) => boolean;
-                    handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+                    matcher: (context: import('better-auth').HookEndpointContext) => boolean;
+                    handler: (inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<void>;
                 }[];
             };
-            options: import("better-auth/plugins/multi-session").MultiSessionConfig | undefined;
+            options: import('better-auth/plugins/multi-session').MultiSessionConfig | undefined;
             $ERROR_CODES: {
-                INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
+                INVALID_SESSION_TOKEN: import('better-auth').RawError<"INVALID_SESSION_TOKEN">;
             };
         }>;
         atomListeners: {
@@ -278,15 +277,759 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
             signal: "$sessionSignal";
         }[];
         $ERROR_CODES: {
-            INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
+            INVALID_SESSION_TOKEN: import('better-auth').RawError<"INVALID_SESSION_TOKEN">;
+        };
+    } | {
+        id: "passkey";
+        version: string;
+        $InferServerPlugin: ReturnType<(options?: import('@better-auth/passkey/client').PasskeyOptions | undefined) => {
+            id: "passkey";
+            version: string;
+            endpoints: {
+                generatePasskeyRegistrationOptions: import('better-auth').StrictEndpoint<"/passkey/generate-register-options", {
+                    method: "GET";
+                    use: ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>)[] | undefined;
+                    query: import('zod').ZodOptional<import('zod').ZodObject<{
+                        authenticatorAttachment: import('zod').ZodOptional<import('zod').ZodEnum<{
+                            platform: "platform";
+                            "cross-platform": "cross-platform";
+                        }>>;
+                        name: import('zod').ZodOptional<import('zod').ZodString>;
+                        context: import('zod').ZodOptional<import('zod').ZodString>;
+                    }, import('zod/v4/core').$strip>>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    parameters: {
+                                        query: {
+                                            authenticatorAttachment: {
+                                                description: string;
+                                                required: boolean;
+                                            };
+                                            name: {
+                                                description: string;
+                                                required: boolean;
+                                            };
+                                            context: {
+                                                description: string;
+                                                required: boolean;
+                                            };
+                                        };
+                                    };
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    challenge: {
+                                                        type: string;
+                                                    };
+                                                    rp: {
+                                                        type: string;
+                                                        properties: {
+                                                            name: {
+                                                                type: string;
+                                                            };
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    user: {
+                                                        type: string;
+                                                        properties: {
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                            name: {
+                                                                type: string;
+                                                            };
+                                                            displayName: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    pubKeyCredParams: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                            properties: {
+                                                                type: {
+                                                                    type: string;
+                                                                };
+                                                                alg: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    timeout: {
+                                                        type: string;
+                                                    };
+                                                    excludeCredentials: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                            properties: {
+                                                                id: {
+                                                                    type: string;
+                                                                };
+                                                                type: {
+                                                                    type: string;
+                                                                };
+                                                                transports: {
+                                                                    type: string;
+                                                                    items: {
+                                                                        type: string;
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    authenticatorSelection: {
+                                                        type: string;
+                                                        properties: {
+                                                            authenticatorAttachment: {
+                                                                type: string;
+                                                            };
+                                                            requireResidentKey: {
+                                                                type: string;
+                                                            };
+                                                            userVerification: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    attestation: {
+                                                        type: string;
+                                                    };
+                                                    extensions: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import('@better-auth/passkey/client').PublicKeyCredentialCreationOptionsJSON>;
+                generatePasskeyAuthenticationOptions: import('better-auth').StrictEndpoint<"/passkey/generate-authenticate-options", {
+                    method: "GET";
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    challenge: {
+                                                        type: string;
+                                                    };
+                                                    rp: {
+                                                        type: string;
+                                                        properties: {
+                                                            name: {
+                                                                type: string;
+                                                            };
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    user: {
+                                                        type: string;
+                                                        properties: {
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                            name: {
+                                                                type: string;
+                                                            };
+                                                            displayName: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    timeout: {
+                                                        type: string;
+                                                    };
+                                                    allowCredentials: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                            properties: {
+                                                                id: {
+                                                                    type: string;
+                                                                };
+                                                                type: {
+                                                                    type: string;
+                                                                };
+                                                                transports: {
+                                                                    type: string;
+                                                                    items: {
+                                                                        type: string;
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    userVerification: {
+                                                        type: string;
+                                                    };
+                                                    authenticatorSelection: {
+                                                        type: string;
+                                                        properties: {
+                                                            authenticatorAttachment: {
+                                                                type: string;
+                                                            };
+                                                            requireResidentKey: {
+                                                                type: string;
+                                                            };
+                                                            userVerification: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    extensions: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import('@better-auth/passkey/client').PublicKeyCredentialRequestOptionsJSON>;
+                verifyPasskeyRegistration: import('better-auth').StrictEndpoint<"/passkey/verify-registration", {
+                    method: "POST";
+                    body: import('zod').ZodObject<{
+                        response: import('zod').ZodAny;
+                        name: import('zod').ZodOptional<import('zod').ZodString>;
+                    }, import('zod/v4/core').$strip>;
+                    use: ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>)[] | undefined;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                $ref: string;
+                                            };
+                                        };
+                                    };
+                                };
+                                400: {
+                                    description: string;
+                                };
+                            };
+                        };
+                    };
+                }, import('@better-auth/passkey/client').Passkey>;
+                verifyPasskeyAuthentication: import('better-auth').StrictEndpoint<"/passkey/verify-authentication", {
+                    method: "POST";
+                    body: import('zod').ZodObject<{
+                        response: import('zod').ZodRecord<import('zod').ZodAny, import('zod').ZodAny>;
+                    }, import('zod/v4/core').$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    session: {
+                                                        $ref: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+                            };
+                        };
+                    };
+                }, {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                }>;
+                listPasskeys: import('better-auth').StrictEndpoint<"/passkey/list-user-passkeys", {
+                    method: "GET";
+                    use: ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "array";
+                                                items: {
+                                                    $ref: string;
+                                                    required: string[];
+                                                };
+                                                description: string;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import('@better-auth/passkey/client').Passkey[]>;
+                deletePasskey: import('better-auth').StrictEndpoint<"/passkey/delete-passkey", {
+                    method: "POST";
+                    body: import('zod').ZodObject<{
+                        id: import('zod').ZodString;
+                    }, import('zod/v4/core').$strip>;
+                    use: (((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>) | ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        verifiedResource: {};
+                    }>))[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    status: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    status: boolean;
+                }>;
+                updatePasskey: import('better-auth').StrictEndpoint<"/passkey/update-passkey", {
+                    method: "POST";
+                    body: import('zod').ZodObject<{
+                        id: import('zod').ZodString;
+                        name: import('zod').ZodString;
+                    }, import('zod/v4/core').$strip>;
+                    use: (((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>) | ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        verifiedResource: {};
+                    }>))[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    passkey: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    passkey: import('@better-auth/passkey/client').Passkey;
+                }>;
+            };
+            schema: {
+                passkey: {
+                    fields: {
+                        name: {
+                            type: "string";
+                            required: false;
+                        };
+                        publicKey: {
+                            type: "string";
+                            required: true;
+                        };
+                        userId: {
+                            type: "string";
+                            references: {
+                                model: string;
+                                field: string;
+                            };
+                            required: true;
+                            index: true;
+                        };
+                        credentialID: {
+                            type: "string";
+                            required: true;
+                            index: true;
+                        };
+                        counter: {
+                            type: "number";
+                            required: true;
+                        };
+                        deviceType: {
+                            type: "string";
+                            required: true;
+                        };
+                        backedUp: {
+                            type: "boolean";
+                            required: true;
+                        };
+                        transports: {
+                            type: "string";
+                            required: false;
+                        };
+                        createdAt: {
+                            type: "date";
+                            required: false;
+                        };
+                        aaguid: {
+                            type: "string";
+                            required: false;
+                        };
+                    };
+                };
+            };
+            $ERROR_CODES: {
+                CHALLENGE_NOT_FOUND: import('better-auth').RawError<"CHALLENGE_NOT_FOUND">;
+                YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: import('better-auth').RawError<"YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY">;
+                FAILED_TO_VERIFY_REGISTRATION: import('better-auth').RawError<"FAILED_TO_VERIFY_REGISTRATION">;
+                PASSKEY_NOT_FOUND: import('better-auth').RawError<"PASSKEY_NOT_FOUND">;
+                AUTHENTICATION_FAILED: import('better-auth').RawError<"AUTHENTICATION_FAILED">;
+                UNABLE_TO_CREATE_SESSION: import('better-auth').RawError<"UNABLE_TO_CREATE_SESSION">;
+                FAILED_TO_UPDATE_PASSKEY: import('better-auth').RawError<"FAILED_TO_UPDATE_PASSKEY">;
+                PREVIOUSLY_REGISTERED: import('better-auth').RawError<"PREVIOUSLY_REGISTERED">;
+                REGISTRATION_CANCELLED: import('better-auth').RawError<"REGISTRATION_CANCELLED">;
+                AUTH_CANCELLED: import('better-auth').RawError<"AUTH_CANCELLED">;
+                UNKNOWN_ERROR: import('better-auth').RawError<"UNKNOWN_ERROR">;
+                SESSION_REQUIRED: import('better-auth').RawError<"SESSION_REQUIRED">;
+                RESOLVE_USER_REQUIRED: import('better-auth').RawError<"RESOLVE_USER_REQUIRED">;
+                RESOLVED_USER_INVALID: import('better-auth').RawError<"RESOLVED_USER_INVALID">;
+            };
+            options: import('@better-auth/passkey/client').PasskeyOptions | undefined;
+        }>;
+        getActions: ($fetch: import('better-auth/client').BetterFetch, $store: import('better-auth').ClientStore) => {
+            signIn: {
+                passkey: (opts?: {
+                    autoFill?: boolean;
+                    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+                    returnWebAuthnResponse?: boolean;
+                    fetchOptions?: import('better-auth').ClientFetchOption;
+                } | undefined, options?: import('better-auth').ClientFetchOption | undefined) => Promise<{
+                    data: null;
+                    error: {
+                        message?: string | undefined;
+                        status: number;
+                        statusText: string;
+                    };
+                } | {
+                    data: {
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                    error: null;
+                } | {
+                    webauthn: {
+                        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+                        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+                    };
+                    data: null;
+                    error: {
+                        message?: string | undefined;
+                        status: number;
+                        statusText: string;
+                    };
+                } | {
+                    webauthn: {
+                        response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+                        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+                    };
+                    data: {
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                    error: null;
+                } | {
+                    data: null;
+                    error: {
+                        code: string;
+                        message: string;
+                        status: number;
+                        statusText: string;
+                    };
+                }>;
+            };
+            passkey: {
+                addPasskey: (opts?: {
+                    fetchOptions?: import('better-auth').ClientFetchOption;
+                    name?: string;
+                    authenticatorAttachment?: "platform" | "cross-platform";
+                    context?: string | null;
+                    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+                    useAutoRegister?: boolean;
+                    returnWebAuthnResponse?: boolean;
+                } | undefined, fetchOpts?: import('better-auth').ClientFetchOption | undefined) => Promise<{
+                    data: null;
+                    error: {
+                        message?: string | undefined;
+                        status: number;
+                        statusText: string;
+                    };
+                } | {
+                    data: import('@better-auth/passkey/client').Passkey;
+                    error: null;
+                } | {
+                    webauthn: {
+                        response: import('@better-auth/passkey/client').RegistrationResponseJSON;
+                        clientExtensionResults: import('@better-auth/passkey/client').AuthenticationExtensionsClientOutputs;
+                    };
+                    data: import('@better-auth/passkey/client').Passkey;
+                    error: null;
+                } | {
+                    data: null;
+                    error: {
+                        code: string;
+                        message: string;
+                        status: number;
+                        statusText: string;
+                    };
+                }>;
+            };
+            $Infer: {
+                Passkey: import('@better-auth/passkey/client').Passkey;
+            };
+        };
+        getAtoms($fetch: import('better-auth/client').BetterFetch): {
+            listPasskeys: import('better-auth/client').AuthQueryAtom<import('@better-auth/passkey/client').Passkey[]>;
+            $listPasskeys: import('better-auth/client').PreinitializedWritableAtom<any> & object;
+        };
+        pathMethods: {
+            "/passkey/register": "POST";
+            "/passkey/authenticate": "POST";
+        };
+        atomListeners: ({
+            matcher(path: string): path is "/passkey/delete-passkey" | "/passkey/update-passkey" | "/passkey/verify-registration" | "/sign-out";
+            signal: "$listPasskeys";
+        } | {
+            matcher: (path: string) => path is "/passkey/verify-authentication";
+            signal: "$sessionSignal";
+        })[];
+        $ERROR_CODES: {
+            CHALLENGE_NOT_FOUND: import('better-auth').RawError<"CHALLENGE_NOT_FOUND">;
+            YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: import('better-auth').RawError<"YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY">;
+            FAILED_TO_VERIFY_REGISTRATION: import('better-auth').RawError<"FAILED_TO_VERIFY_REGISTRATION">;
+            PASSKEY_NOT_FOUND: import('better-auth').RawError<"PASSKEY_NOT_FOUND">;
+            AUTHENTICATION_FAILED: import('better-auth').RawError<"AUTHENTICATION_FAILED">;
+            UNABLE_TO_CREATE_SESSION: import('better-auth').RawError<"UNABLE_TO_CREATE_SESSION">;
+            FAILED_TO_UPDATE_PASSKEY: import('better-auth').RawError<"FAILED_TO_UPDATE_PASSKEY">;
+            PREVIOUSLY_REGISTERED: import('better-auth').RawError<"PREVIOUSLY_REGISTERED">;
+            REGISTRATION_CANCELLED: import('better-auth').RawError<"REGISTRATION_CANCELLED">;
+            AUTH_CANCELLED: import('better-auth').RawError<"AUTH_CANCELLED">;
+            UNKNOWN_ERROR: import('better-auth').RawError<"UNKNOWN_ERROR">;
+            SESSION_REQUIRED: import('better-auth').RawError<"SESSION_REQUIRED">;
+            RESOLVE_USER_REQUIRED: import('better-auth').RawError<"RESOLVE_USER_REQUIRED">;
+            RESOLVED_USER_INVALID: import('better-auth').RawError<"RESOLVED_USER_INVALID">;
         };
     } | {
         id: "username";
         version: string;
-        $InferServerPlugin: ReturnType<(options?: import("better-auth/plugins/username").UsernameOptions | undefined) => {
+        $InferServerPlugin: ReturnType<(options?: import('better-auth/plugins/username').UsernameOptions | undefined) => {
             id: "username";
             version: string;
-            init(ctx: import("better-auth").AuthContext): {
+            init(ctx: import('better-auth').AuthContext): {
                 options: {
                     databaseHooks: {
                         user: {
@@ -299,7 +1042,7 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                                     emailVerified: boolean;
                                     name: string;
                                     image?: string | null | undefined;
-                                } & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                                } & Record<string, unknown>, context: import('better-auth').GenericEndpointContext | null): Promise<{
                                     data: {
                                         displayUsername?: string | undefined;
                                         username?: string | undefined;
@@ -322,7 +1065,7 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                                     emailVerified: boolean;
                                     name: string;
                                     image?: string | null | undefined;
-                                }> & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                                }> & Record<string, unknown>, context: import('better-auth').GenericEndpointContext | null): Promise<{
                                     data: {
                                         displayUsername?: string | undefined;
                                         username?: string | undefined;
@@ -341,14 +1084,14 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                 };
             };
             endpoints: {
-                signInUsername: import("better-auth").StrictEndpoint<"/sign-in/username", {
+                signInUsername: import('better-auth').StrictEndpoint<"/sign-in/username", {
                     method: "POST";
-                    body: import("zod").ZodObject<{
-                        username: import("zod").ZodString;
-                        password: import("zod").ZodString;
-                        rememberMe: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                        callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
-                    }, import("zod/v4/core").$strip>;
+                    body: import('zod').ZodObject<{
+                        username: import('zod').ZodString;
+                        password: import('zod').ZodString;
+                        rememberMe: import('zod').ZodOptional<import('zod').ZodBoolean>;
+                        callbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                    }, import('zod/v4/core').$strip>;
                     metadata: {
                         openapi: {
                             summary: string;
@@ -407,11 +1150,11 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                         displayUsername: string;
                     };
                 }>;
-                isUsernameAvailable: import("better-auth").StrictEndpoint<"/is-username-available", {
+                isUsernameAvailable: import('better-auth').StrictEndpoint<"/is-username-available", {
                     method: "POST";
-                    body: import("zod").ZodObject<{
-                        username: import("zod").ZodString;
-                    }, import("zod/v4/core").$strip>;
+                    body: import('zod').ZodObject<{
+                        username: import('zod').ZodString;
+                    }, import('zod/v4/core').$strip>;
                 }, {
                     available: boolean;
                 }>;
@@ -426,14 +1169,14 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
                             unique: true;
                             returned: true;
                             transform: {
-                                input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
+                                input(value: import('better-auth').DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
                             };
                         };
                         displayUsername: {
                             type: "string";
                             required: false;
                             transform: {
-                                input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
+                                input(value: import('better-auth').DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
                             };
                         };
                     };
@@ -441,20 +1184,20 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
             };
             hooks: {
                 before: {
-                    matcher(context: import("better-auth").HookEndpointContext): boolean;
-                    handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+                    matcher(context: import('better-auth').HookEndpointContext): boolean;
+                    handler: (inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<void>;
                 }[];
             };
-            options: import("better-auth/plugins/username").UsernameOptions | undefined;
+            options: import('better-auth/plugins/username').UsernameOptions | undefined;
             $ERROR_CODES: {
-                EMAIL_NOT_VERIFIED: import("better-auth").RawError<"EMAIL_NOT_VERIFIED">;
-                UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;
-                INVALID_USERNAME_OR_PASSWORD: import("better-auth").RawError<"INVALID_USERNAME_OR_PASSWORD">;
-                USERNAME_IS_ALREADY_TAKEN: import("better-auth").RawError<"USERNAME_IS_ALREADY_TAKEN">;
-                USERNAME_TOO_SHORT: import("better-auth").RawError<"USERNAME_TOO_SHORT">;
-                USERNAME_TOO_LONG: import("better-auth").RawError<"USERNAME_TOO_LONG">;
-                INVALID_USERNAME: import("better-auth").RawError<"INVALID_USERNAME">;
-                INVALID_DISPLAY_USERNAME: import("better-auth").RawError<"INVALID_DISPLAY_USERNAME">;
+                EMAIL_NOT_VERIFIED: import('better-auth').RawError<"EMAIL_NOT_VERIFIED">;
+                UNEXPECTED_ERROR: import('better-auth').RawError<"UNEXPECTED_ERROR">;
+                INVALID_USERNAME_OR_PASSWORD: import('better-auth').RawError<"INVALID_USERNAME_OR_PASSWORD">;
+                USERNAME_IS_ALREADY_TAKEN: import('better-auth').RawError<"USERNAME_IS_ALREADY_TAKEN">;
+                USERNAME_TOO_SHORT: import('better-auth').RawError<"USERNAME_TOO_SHORT">;
+                USERNAME_TOO_LONG: import('better-auth').RawError<"USERNAME_TOO_LONG">;
+                INVALID_USERNAME: import('better-auth').RawError<"INVALID_USERNAME">;
+                INVALID_DISPLAY_USERNAME: import('better-auth').RawError<"INVALID_DISPLAY_USERNAME">;
             };
         }>;
         atomListeners: {
@@ -462,17 +1205,17 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
             signal: "$sessionSignal";
         }[];
         $ERROR_CODES: {
-            EMAIL_NOT_VERIFIED: import("better-auth").RawError<"EMAIL_NOT_VERIFIED">;
-            UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;
-            INVALID_USERNAME_OR_PASSWORD: import("better-auth").RawError<"INVALID_USERNAME_OR_PASSWORD">;
-            USERNAME_IS_ALREADY_TAKEN: import("better-auth").RawError<"USERNAME_IS_ALREADY_TAKEN">;
-            USERNAME_TOO_SHORT: import("better-auth").RawError<"USERNAME_TOO_SHORT">;
-            USERNAME_TOO_LONG: import("better-auth").RawError<"USERNAME_TOO_LONG">;
-            INVALID_USERNAME: import("better-auth").RawError<"INVALID_USERNAME">;
-            INVALID_DISPLAY_USERNAME: import("better-auth").RawError<"INVALID_DISPLAY_USERNAME">;
+            EMAIL_NOT_VERIFIED: import('better-auth').RawError<"EMAIL_NOT_VERIFIED">;
+            UNEXPECTED_ERROR: import('better-auth').RawError<"UNEXPECTED_ERROR">;
+            INVALID_USERNAME_OR_PASSWORD: import('better-auth').RawError<"INVALID_USERNAME_OR_PASSWORD">;
+            USERNAME_IS_ALREADY_TAKEN: import('better-auth').RawError<"USERNAME_IS_ALREADY_TAKEN">;
+            USERNAME_TOO_SHORT: import('better-auth').RawError<"USERNAME_TOO_SHORT">;
+            USERNAME_TOO_LONG: import('better-auth').RawError<"USERNAME_TOO_LONG">;
+            INVALID_USERNAME: import('better-auth').RawError<"INVALID_USERNAME">;
+            INVALID_DISPLAY_USERNAME: import('better-auth').RawError<"INVALID_DISPLAY_USERNAME">;
         };
     })[];
-}, FetchOptions>>, data_1?: FetchOptions | undefined) => Promise<import("better-auth/react").BetterFetchResponse<(Omit<{
+}, FetchOptions>>, data_1?: FetchOptions | undefined) => Promise<import('better-auth/client').BetterFetchResponse<(Omit<{
     token: null;
     user: {
         id: string;
@@ -484,7 +1227,7 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
         image?: string | null | undefined | undefined;
     };
 }, "user"> & {
-    user: import("better-auth").StripEmptyObjects<{
+    user: import('better-auth').StripEmptyObjects<{
         id: string;
         createdAt: Date;
         updatedAt: Date;
@@ -508,7 +1251,7 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
         image?: string | null | undefined | undefined;
     };
 }, "user"> & {
-    user: import("better-auth").StripEmptyObjects<{
+    user: import('better-auth').StripEmptyObjects<{
         id: string;
         createdAt: Date;
         updatedAt: Date;