@better-auth-ui/react 1.6.0 → 1.6.1

package/dist/lib/auth-client.d.ts

@@ -9,6 +9,16 @@ export type { PathToObject } from "better-auth/client";
  */
 export type AnyAuthClient = Omit<ReturnType<typeof createAuthClient>, "signUp">;
 declare const authClient: {
+    useListPasskeys: () => {
+        data: import("@better-auth/passkey/client").Passkey[] | null;
+        error: null | import("better-auth/react").BetterFetchError;
+        isPending: boolean;
+        isRefetching: boolean;
+        refetch: (queryParams?: {
+            query?: import("better-auth").SessionQueryParams;
+        } | undefined) => Promise<void>;
+    };
+} & {
     deleteUser: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
         callbackURL?: string | undefined;
         password?: string | undefined;
@@ -488,107 +498,250 @@ declare const authClient: {
                     INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
                 };
             } | {
-                id: "username";
+                id: "passkey";
                 version: string;
-                $InferServerPlugin: ReturnType<(options?: import("better-auth/plugins/username").UsernameOptions | undefined) => {
-                    id: "username";
+                $InferServerPlugin: ReturnType<(options?: import("@better-auth/passkey/client").PasskeyOptions | undefined) => {
+                    id: "passkey";
                     version: string;
-                    init(ctx: import("better-auth").AuthContext): {
-                        options: {
-                            databaseHooks: {
-                                user: {
-                                    create: {
-                                        before(user: {
-                                            id: string;
-                                            createdAt: Date;
-                                            updatedAt: Date;
-                                            email: string;
-                                            emailVerified: boolean;
-                                            name: string;
-                                            image?: string | null | undefined;
-                                        } & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
-                                            data: {
-                                                displayUsername?: string | undefined;
-                                                username?: string | undefined;
-                                                id: string;
-                                                createdAt: Date;
-                                                updatedAt: Date;
-                                                email: string;
-                                                emailVerified: boolean;
-                                                name: string;
-                                                image?: string | null | undefined;
-                                            };
-                                        }>;
+                    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;
                                     };
-                                    update: {
-                                        before(user: Partial<{
-                                            id: string;
-                                            createdAt: Date;
-                                            updatedAt: Date;
-                                            email: string;
-                                            emailVerified: boolean;
-                                            name: string;
-                                            image?: string | null | undefined;
-                                        }> & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
-                                            data: {
-                                                displayUsername?: string | undefined;
-                                                username?: string | undefined;
-                                                id?: string | undefined;
-                                                createdAt?: Date | undefined;
-                                                updatedAt?: Date | undefined;
-                                                email?: string | undefined;
-                                                emailVerified?: boolean | undefined;
-                                                name?: string | undefined;
-                                                image?: string | null | undefined;
-                                            };
-                                        }>;
+                                    user: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        email: string;
+                                        emailVerified: boolean;
+                                        name: string;
+                                        image?: string | null | undefined;
                                     };
                                 };
-                            };
-                        };
-                    };
-                    endpoints: {
-                        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>;
+                            }>)[] | 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: {
-                                    summary: string;
+                                    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: {
-                                                            token: {
+                                                            challenge: {
                                                                 type: string;
-                                                                description: string;
+                                                            };
+                                                            rp: {
+                                                                type: string;
+                                                                properties: {
+                                                                    name: {
+                                                                        type: string;
+                                                                    };
+                                                                    id: {
+                                                                        type: string;
+                                                                    };
+                                                                };
                                                             };
                                                             user: {
-                                                                $ref: string;
+                                                                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;
                                                             };
                                                         };
-                                                        required: string[];
                                                     };
                                                 };
                                             };
                                         };
-                                        422: {
+                                    };
+                                };
+                            };
+                        }, 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: {
-                                                            message: {
+                                                            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;
                                                             };
                                                         };
@@ -599,59 +752,660 @@ declare const authClient: {
                                     };
                                 };
                             };
-                        }, {
-                            token: string;
-                            user: {
-                                id: string;
-                                createdAt: Date;
-                                updatedAt: Date;
-                                email: string;
-                                emailVerified: boolean;
-                                name: string;
-                                image?: string | null | undefined;
-                            } & {
-                                username: string;
-                                displayUsername: 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;
+                                        };
+                                    };
+                                };
                             };
-                        }>;
-                        isUsernameAvailable: import("better-auth").StrictEndpoint<"/is-username-available", {
+                        }, import("@better-auth/passkey/client").Passkey>;
+                        verifyPasskeyAuthentication: import("better-auth").StrictEndpoint<"/passkey/verify-authentication", {
                             method: "POST";
                             body: import("zod").ZodObject<{
-                                username: import("zod").ZodString;
+                                response: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
                             }, import("zod/v4/core").$strip>;
-                        }, {
-                            available: boolean;
-                        }>;
-                    };
-                    schema: {
-                        user: {
-                            fields: {
-                                username: {
-                                    type: "string";
-                                    required: false;
-                                    sortable: true;
-                                    unique: true;
-                                    returned: true;
-                                    transform: {
-                                        input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
+                            metadata: {
+                                openapi: {
+                                    operationId: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            session: {
+                                                                $ref: string;
+                                                            };
+                                                            user: {
+                                                                $ref: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
                                     };
                                 };
-                                displayUsername: {
-                                    type: "string";
-                                    required: false;
-                                    transform: {
-                                        input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
+                                $Infer: {
+                                    body: {
+                                        response: import("@better-auth/passkey/client").AuthenticationResponseJSON;
                                     };
                                 };
                             };
-                        };
-                    };
-                    hooks: {
-                        before: {
-                            matcher(context: import("better-auth").HookEndpointContext): boolean;
-                            handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
-                        }[];
-                    };
+                        }, {
+                            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/react").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/react").BetterFetch): {
+                    listPasskeys: import("better-auth/client").AuthQueryAtom<import("@better-auth/passkey/client").Passkey[]>;
+                    $listPasskeys: import("better-auth/react").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) => {
+                    id: "username";
+                    version: string;
+                    init(ctx: import("better-auth").AuthContext): {
+                        options: {
+                            databaseHooks: {
+                                user: {
+                                    create: {
+                                        before(user: {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            email: string;
+                                            emailVerified: boolean;
+                                            name: string;
+                                            image?: string | null | undefined;
+                                        } & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                                            data: {
+                                                displayUsername?: string | undefined;
+                                                username?: string | undefined;
+                                                id: string;
+                                                createdAt: Date;
+                                                updatedAt: Date;
+                                                email: string;
+                                                emailVerified: boolean;
+                                                name: string;
+                                                image?: string | null | undefined;
+                                            };
+                                        }>;
+                                    };
+                                    update: {
+                                        before(user: Partial<{
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            email: string;
+                                            emailVerified: boolean;
+                                            name: string;
+                                            image?: string | null | undefined;
+                                        }> & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                                            data: {
+                                                displayUsername?: string | undefined;
+                                                username?: string | undefined;
+                                                id?: string | undefined;
+                                                createdAt?: Date | undefined;
+                                                updatedAt?: Date | undefined;
+                                                email?: string | undefined;
+                                                emailVerified?: boolean | undefined;
+                                                name?: string | undefined;
+                                                image?: string | null | undefined;
+                                            };
+                                        }>;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    endpoints: {
+                        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>;
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            token: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            user: {
+                                                                $ref: string;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                        422: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            message: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            token: string;
+                            user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & {
+                                username: string;
+                                displayUsername: string;
+                            };
+                        }>;
+                        isUsernameAvailable: import("better-auth").StrictEndpoint<"/is-username-available", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                username: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>;
+                        }, {
+                            available: boolean;
+                        }>;
+                    };
+                    schema: {
+                        user: {
+                            fields: {
+                                username: {
+                                    type: "string";
+                                    required: false;
+                                    sortable: true;
+                                    unique: true;
+                                    returned: true;
+                                    transform: {
+                                        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;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    hooks: {
+                        before: {
+                            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;
                     $ERROR_CODES: {
                         EMAIL_NOT_VERIFIED: import("better-auth").RawError<"EMAIL_NOT_VERIFIED">;
@@ -844,11 +1598,296 @@ declare const authClient: {
                         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>;
+                            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;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        status: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        status: boolean;
+                    }>;
+                    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>)[];
+                        requireHeaders: true;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        session: {
+                                                            $ref: string;
+                                                        };
+                                                        user: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        token: string;
+                        user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    }>;
+                };
+                rateLimit: {
+                    pathMatcher(path: string): boolean;
+                    window: number;
+                    max: number;
+                }[];
+                options: import("better-auth/plugins/magic-link").MagicLinkOptions;
+            }>;
+        } | {
+            id: "multi-session";
+            version: string;
+            $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", {
+                        method: "GET";
+                        requireHeaders: true;
+                    }, {
+                        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;
+                        };
+                    }[]>;
+                    setActiveSession: import("better-auth").StrictEndpoint<"/multi-session/set-active", {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            sessionToken: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                        requireHeaders: true;
+                        metadata: {
+                            openapi: {
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        session: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        } & Record<string, any>;
+                        user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, any>;
+                    }>;
+                    revokeDeviceSession: import("better-auth").StrictEndpoint<"/multi-session/revoke", {
+                        method: "POST";
+                        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<{
+                            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: "object";
+                                                    properties: {
+                                                        status: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        status: boolean;
+                    }>;
+                };
+                hooks: {
+                    after: {
+                        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;
+                $ERROR_CODES: {
+                    INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
+                };
+            }>;
+            atomListeners: {
+                matcher(path: string): path is "/multi-session/set-active";
+                signal: "$sessionSignal";
+            }[];
+            $ERROR_CODES: {
+                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;
@@ -856,12 +1895,110 @@ declare const authClient: {
                                 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: {
-                                                        status: {
+                                                        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;
                                                         };
                                                     };
@@ -872,19 +2009,157 @@ declare const authClient: {
                                 };
                             };
                         };
-                    }, {
-                        status: boolean;
-                    }>;
-                    magicLinkVerify: import("better-auth").StrictEndpoint<"/magic-link/verify", {
+                    }, import("@better-auth/passkey/client").PublicKeyCredentialCreationOptionsJSON>;
+                    generatePasskeyAuthenticationOptions: import("better-auth").StrictEndpoint<"/passkey/generate-authenticate-options", {
                         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>;
+                        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>;
-                        use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>)[];
-                        requireHeaders: true;
                         metadata: {
                             openapi: {
                                 operationId: string;
@@ -910,18 +2185,13 @@ declare const authClient: {
                                     };
                                 };
                             };
+                            $Infer: {
+                                body: {
+                                    response: import("@better-auth/passkey/client").AuthenticationResponseJSON;
+                                };
+                            };
                         };
                     }, {
-                        token: string;
-                        user: {
-                            id: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                            email: string;
-                            emailVerified: boolean;
-                            name: string;
-                            image?: string | null | undefined;
-                        };
                         session: {
                             id: string;
                             createdAt: Date;
@@ -933,66 +2203,101 @@ declare const authClient: {
                             userAgent?: string | null | undefined;
                         };
                     }>;
-                };
-                rateLimit: {
-                    pathMatcher(path: string): boolean;
-                    window: number;
-                    max: number;
-                }[];
-                options: import("better-auth/plugins/magic-link").MagicLinkOptions;
-            }>;
-        } | {
-            id: "multi-session";
-            version: string;
-            $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", {
+                    listPasskeys: import("better-auth").StrictEndpoint<"/passkey/list-user-passkeys", {
                         method: "GET";
-                        requireHeaders: true;
-                    }, {
-                        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;
+                        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;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
                         };
-                    }[]>;
-                    setActiveSession: import("better-auth").StrictEndpoint<"/multi-session/set-active", {
+                    }, import("@better-auth/passkey/client").Passkey[]>;
+                    deletePasskey: import("better-auth").StrictEndpoint<"/passkey/delete-passkey", {
                         method: "POST";
                         body: import("zod").ZodObject<{
-                            sessionToken: import("zod").ZodString;
+                            id: import("zod").ZodString;
                         }, import("zod/v4/core").$strip>;
-                        requireHeaders: true;
+                        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: {
+                                    "200": {
                                         description: string;
                                         content: {
                                             "application/json": {
                                                 schema: {
                                                     type: "object";
                                                     properties: {
-                                                        session: {
-                                                            $ref: string;
+                                                        status: {
+                                                            type: string;
+                                                            description: string;
                                                         };
                                                     };
+                                                    required: string[];
                                                 };
                                             };
                                         };
@@ -1001,33 +2306,15 @@ declare const authClient: {
                             };
                         };
                     }, {
-                        session: {
-                            id: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                            userId: string;
-                            expiresAt: Date;
-                            token: string;
-                            ipAddress?: string | null | undefined;
-                            userAgent?: string | null | undefined;
-                        } & Record<string, any>;
-                        user: {
-                            id: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                            email: string;
-                            emailVerified: boolean;
-                            name: string;
-                            image?: string | null | undefined;
-                        } & Record<string, any>;
+                        status: boolean;
                     }>;
-                    revokeDeviceSession: import("better-auth").StrictEndpoint<"/multi-session/revoke", {
+                    updatePasskey: import("better-auth").StrictEndpoint<"/passkey/update-passkey", {
                         method: "POST";
                         body: import("zod").ZodObject<{
-                            sessionToken: import("zod").ZodString;
+                            id: import("zod").ZodString;
+                            name: 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;
@@ -1049,22 +2336,25 @@ declare const authClient: {
                                     image?: string | null | undefined;
                                 };
                             };
-                        }>)[];
+                        }>) | ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                            verifiedResource: {};
+                        }>))[];
                         metadata: {
                             openapi: {
                                 description: string;
                                 responses: {
-                                    200: {
+                                    "200": {
                                         description: string;
                                         content: {
                                             "application/json": {
                                                 schema: {
                                                     type: "object";
                                                     properties: {
-                                                        status: {
-                                                            type: string;
+                                                        passkey: {
+                                                            $ref: string;
                                                         };
                                                     };
+                                                    required: string[];
                                                 };
                                             };
                                         };
@@ -1073,26 +2363,234 @@ declare const authClient: {
                             };
                         };
                     }, {
-                        status: boolean;
+                        passkey: import("@better-auth/passkey/client").Passkey;
                     }>;
                 };
-                hooks: {
-                    after: {
-                        matcher: (context: import("better-auth").HookEndpointContext) => boolean;
-                        handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
-                    }[];
+                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;
+                            };
+                        };
+                    };
                 };
-                options: import("better-auth/plugins/multi-session").MultiSessionConfig | undefined;
                 $ERROR_CODES: {
-                    INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
+                    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;
             }>;
-            atomListeners: {
-                matcher(path: string): path is "/multi-session/set-active";
+            getActions: ($fetch: import("better-auth/react").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/react").BetterFetch): {
+                listPasskeys: import("better-auth/client").AuthQueryAtom<import("@better-auth/passkey/client").Passkey[]>;
+                $listPasskeys: import("better-auth/react").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: {
-                INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
+                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";
@@ -1715,6 +3213,115 @@ declare const authClient: {
             message?: string | undefined;
         }, FetchOptions["throw"] extends true ? true : false>>;
     };
+} & {
+    passkey: {
+        generateRegisterOptions: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<{
+            authenticatorAttachment?: "platform" | "cross-platform" | undefined;
+            name?: string | undefined;
+            context?: string | undefined;
+        }> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+            query?: {
+                authenticatorAttachment?: "platform" | "cross-platform" | undefined;
+                name?: string | undefined;
+                context?: string | undefined;
+            } | undefined;
+            fetchOptions?: FetchOptions | undefined;
+        }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/react").BetterFetchResponse<import("@better-auth/passkey/client").PublicKeyCredentialCreationOptionsJSON, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+} & {
+    passkey: {
+        generateAuthenticateOptions: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+            query?: Record<string, any> | undefined;
+            fetchOptions?: FetchOptions | undefined;
+        }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/react").BetterFetchResponse<import("@better-auth/passkey/client").PublicKeyCredentialRequestOptionsJSON, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+} & {
+    passkey: {
+        verifyRegistration: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+            response: any;
+            name?: string | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+            response: any;
+            name?: string | undefined;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("better-auth/react").BetterFetchResponse<import("@better-auth/passkey/client").Passkey, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+} & {
+    passkey: {
+        verifyAuthentication: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+            response: import("@better-auth/passkey/client").AuthenticationResponseJSON;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+            response: import("@better-auth/passkey/client").AuthenticationResponseJSON;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("better-auth/react").BetterFetchResponse<{
+            session: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+            };
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+} & {
+    passkey: {
+        listUserPasskeys: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+            query?: Record<string, any> | undefined;
+            fetchOptions?: FetchOptions | undefined;
+        }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/react").BetterFetchResponse<import("@better-auth/passkey/client").Passkey[], {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+} & {
+    passkey: {
+        deletePasskey: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+            id: string;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+            id: string;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("better-auth/react").BetterFetchResponse<{
+            status: boolean;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    };
+} & {
+    passkey: {
+        updatePasskey: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+            id: string;
+            name: string;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+            id: string;
+            name: string;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("better-auth/react").BetterFetchResponse<{
+            passkey: import("@better-auth/passkey/client").Passkey;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    };
 } & {
     signIn: {
         username: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
@@ -1774,6 +3381,96 @@ declare const authClient: {
         code?: string | undefined;
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
+} & {
+    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: import("better-auth").Session;
+                user: import("better-auth").User;
+            };
+            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: import("better-auth").Session;
+                user: import("better-auth").User;
+            };
+            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;
+    };
 } & {
     useSession: () => {
         data: {
@@ -1906,6 +3603,21 @@ declare const authClient: {
     };
     $ERROR_CODES: {
         INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
+    } & {
+        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">;
     } & {
         EMAIL_NOT_VERIFIED: import("better-auth").RawError<"EMAIL_NOT_VERIFIED">;
         UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;