@better-auth-ui/react 1.6.2 → 1.6.3

package/dist/hooks/settings/use-update-user.d.ts

@@ -1,11 +1,1185 @@
 import { AuthClient } from '../../lib/auth-client';
-import { UseAuthMutationOptions, UseAuthMutationResult } from '../auth/use-auth-mutation';
+import { updateUserOptions } from '../../mutations/settings/update-user-options';
+export type UseUpdateUserParams = NonNullable<Parameters<AuthClient["updateUser"]>[0]>;
+export type UseUpdateUserOptions = Omit<ReturnType<typeof updateUserOptions>, "mutationKey" | "mutationFn">;
 /**
  * Hook that creates a mutation for updating the authenticated user's profile.
  *
- * The mutation submits the name update, refetches the session on success,
- * and displays success or error toasts.
+ * Optimistically merges the update into the cached session, then refetches
+ * the session to reconcile with the server.
  *
+ * @param options - React Query options forwarded to `useMutation`.
  * @returns The `useMutation` result.
  */
-export declare function useUpdateUser(options?: UseAuthMutationOptions<AuthClient["updateUser"]>): UseAuthMutationResult<AuthClient["updateUser"]>;
+export declare function useUpdateUser(options?: UseUpdateUserOptions): import('@tanstack/react-query').UseMutationResult<{
+    status: boolean;
+} | null, import('better-auth/client').BetterFetchError, void | import('better-auth').Prettify<import('better-auth/client').InferUserUpdateCtx<{
+    plugins: ({
+        id: "magic-link";
+        version: string;
+        $InferServerPlugin: ReturnType<(options: import('better-auth/plugins/magic-link').MagicLinkOptions) => {
+            id: "magic-link";
+            version: string;
+            endpoints: {
+                signInMagicLink: import('better-auth').StrictEndpoint<"/sign-in/magic-link", {
+                    method: "POST";
+                    requireHeaders: true;
+                    body: import('zod').ZodObject<{
+                        email: import('zod').ZodEmail;
+                        name: import('zod').ZodOptional<import('zod').ZodString>;
+                        callbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                        newUserCallbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                        errorCallbackURL: import('zod').ZodOptional<import('zod').ZodString>;
+                        metadata: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodAny>>;
+                    }, import('zod/v4/core').$strip>;
+                    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;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    parameters: {
+                                        query: {
+                                            authenticatorAttachment: {
+                                                description: string;
+                                                required: boolean;
+                                            };
+                                            name: {
+                                                description: string;
+                                                required: boolean;
+                                            };
+                                            context: {
+                                                description: string;
+                                                required: boolean;
+                                            };
+                                        };
+                                    };
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    challenge: {
+                                                        type: string;
+                                                    };
+                                                    rp: {
+                                                        type: string;
+                                                        properties: {
+                                                            name: {
+                                                                type: string;
+                                                            };
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    user: {
+                                                        type: string;
+                                                        properties: {
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                            name: {
+                                                                type: string;
+                                                            };
+                                                            displayName: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    pubKeyCredParams: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                            properties: {
+                                                                type: {
+                                                                    type: string;
+                                                                };
+                                                                alg: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    timeout: {
+                                                        type: string;
+                                                    };
+                                                    excludeCredentials: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                            properties: {
+                                                                id: {
+                                                                    type: string;
+                                                                };
+                                                                type: {
+                                                                    type: string;
+                                                                };
+                                                                transports: {
+                                                                    type: string;
+                                                                    items: {
+                                                                        type: string;
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    authenticatorSelection: {
+                                                        type: string;
+                                                        properties: {
+                                                            authenticatorAttachment: {
+                                                                type: string;
+                                                            };
+                                                            requireResidentKey: {
+                                                                type: string;
+                                                            };
+                                                            userVerification: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    attestation: {
+                                                        type: string;
+                                                    };
+                                                    extensions: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import('@better-auth/passkey/client').PublicKeyCredentialCreationOptionsJSON>;
+                generatePasskeyAuthenticationOptions: import('better-auth').StrictEndpoint<"/passkey/generate-authenticate-options", {
+                    method: "GET";
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    challenge: {
+                                                        type: string;
+                                                    };
+                                                    rp: {
+                                                        type: string;
+                                                        properties: {
+                                                            name: {
+                                                                type: string;
+                                                            };
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    user: {
+                                                        type: string;
+                                                        properties: {
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                            name: {
+                                                                type: string;
+                                                            };
+                                                            displayName: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    timeout: {
+                                                        type: string;
+                                                    };
+                                                    allowCredentials: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                            properties: {
+                                                                id: {
+                                                                    type: string;
+                                                                };
+                                                                type: {
+                                                                    type: string;
+                                                                };
+                                                                transports: {
+                                                                    type: string;
+                                                                    items: {
+                                                                        type: string;
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    userVerification: {
+                                                        type: string;
+                                                    };
+                                                    authenticatorSelection: {
+                                                        type: string;
+                                                        properties: {
+                                                            authenticatorAttachment: {
+                                                                type: string;
+                                                            };
+                                                            requireResidentKey: {
+                                                                type: string;
+                                                            };
+                                                            userVerification: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                    extensions: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import('@better-auth/passkey/client').PublicKeyCredentialRequestOptionsJSON>;
+                verifyPasskeyRegistration: import('better-auth').StrictEndpoint<"/passkey/verify-registration", {
+                    method: "POST";
+                    body: import('zod').ZodObject<{
+                        response: import('zod').ZodAny;
+                        name: import('zod').ZodOptional<import('zod').ZodString>;
+                    }, import('zod/v4/core').$strip>;
+                    use: ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>)[] | undefined;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                $ref: string;
+                                            };
+                                        };
+                                    };
+                                };
+                                400: {
+                                    description: string;
+                                };
+                            };
+                        };
+                    };
+                }, import('@better-auth/passkey/client').Passkey>;
+                verifyPasskeyAuthentication: import('better-auth').StrictEndpoint<"/passkey/verify-authentication", {
+                    method: "POST";
+                    body: import('zod').ZodObject<{
+                        response: import('zod').ZodRecord<import('zod').ZodAny, import('zod').ZodAny>;
+                    }, import('zod/v4/core').$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    session: {
+                                                        $ref: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                response: import('@better-auth/passkey/client').AuthenticationResponseJSON;
+                            };
+                        };
+                    };
+                }, {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                }>;
+                listPasskeys: import('better-auth').StrictEndpoint<"/passkey/list-user-passkeys", {
+                    method: "GET";
+                    use: ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "array";
+                                                items: {
+                                                    $ref: string;
+                                                    required: string[];
+                                                };
+                                                description: string;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import('@better-auth/passkey/client').Passkey[]>;
+                deletePasskey: import('better-auth').StrictEndpoint<"/passkey/delete-passkey", {
+                    method: "POST";
+                    body: import('zod').ZodObject<{
+                        id: import('zod').ZodString;
+                    }, import('zod/v4/core').$strip>;
+                    use: (((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>) | ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        verifiedResource: {};
+                    }>))[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    status: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    status: boolean;
+                }>;
+                updatePasskey: import('better-auth').StrictEndpoint<"/passkey/update-passkey", {
+                    method: "POST";
+                    body: import('zod').ZodObject<{
+                        id: import('zod').ZodString;
+                        name: import('zod').ZodString;
+                    }, import('zod/v4/core').$strip>;
+                    use: (((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>) | ((inputContext: import('better-auth').MiddlewareInputContext<import('better-auth').MiddlewareOptions>) => Promise<{
+                        verifiedResource: {};
+                    }>))[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    passkey: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    passkey: import('@better-auth/passkey/client').Passkey;
+                }>;
+            };
+            schema: {
+                passkey: {
+                    fields: {
+                        name: {
+                            type: "string";
+                            required: false;
+                        };
+                        publicKey: {
+                            type: "string";
+                            required: true;
+                        };
+                        userId: {
+                            type: "string";
+                            references: {
+                                model: string;
+                                field: string;
+                            };
+                            required: true;
+                            index: true;
+                        };
+                        credentialID: {
+                            type: "string";
+                            required: true;
+                            index: true;
+                        };
+                        counter: {
+                            type: "number";
+                            required: true;
+                        };
+                        deviceType: {
+                            type: "string";
+                            required: true;
+                        };
+                        backedUp: {
+                            type: "boolean";
+                            required: true;
+                        };
+                        transports: {
+                            type: "string";
+                            required: false;
+                        };
+                        createdAt: {
+                            type: "date";
+                            required: false;
+                        };
+                        aaguid: {
+                            type: "string";
+                            required: false;
+                        };
+                    };
+                };
+            };
+            $ERROR_CODES: {
+                CHALLENGE_NOT_FOUND: import('better-auth').RawError<"CHALLENGE_NOT_FOUND">;
+                YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: import('better-auth').RawError<"YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY">;
+                FAILED_TO_VERIFY_REGISTRATION: import('better-auth').RawError<"FAILED_TO_VERIFY_REGISTRATION">;
+                PASSKEY_NOT_FOUND: import('better-auth').RawError<"PASSKEY_NOT_FOUND">;
+                AUTHENTICATION_FAILED: import('better-auth').RawError<"AUTHENTICATION_FAILED">;
+                UNABLE_TO_CREATE_SESSION: import('better-auth').RawError<"UNABLE_TO_CREATE_SESSION">;
+                FAILED_TO_UPDATE_PASSKEY: import('better-auth').RawError<"FAILED_TO_UPDATE_PASSKEY">;
+                PREVIOUSLY_REGISTERED: import('better-auth').RawError<"PREVIOUSLY_REGISTERED">;
+                REGISTRATION_CANCELLED: import('better-auth').RawError<"REGISTRATION_CANCELLED">;
+                AUTH_CANCELLED: import('better-auth').RawError<"AUTH_CANCELLED">;
+                UNKNOWN_ERROR: import('better-auth').RawError<"UNKNOWN_ERROR">;
+                SESSION_REQUIRED: import('better-auth').RawError<"SESSION_REQUIRED">;
+                RESOLVE_USER_REQUIRED: import('better-auth').RawError<"RESOLVE_USER_REQUIRED">;
+                RESOLVED_USER_INVALID: import('better-auth').RawError<"RESOLVED_USER_INVALID">;
+            };
+            options: import('@better-auth/passkey/client').PasskeyOptions | undefined;
+        }>;
+        getActions: ($fetch: import('better-auth/client').BetterFetch, $store: import('better-auth').ClientStore) => {
+            signIn: {
+                passkey: (opts?: {
+                    autoFill?: boolean;
+                    extensions?: import('@better-auth/passkey/client').AuthenticationExtensionsClientInputs;
+                    returnWebAuthnResponse?: boolean;
+                    fetchOptions?: import('better-auth').ClientFetchOption;
+                } | undefined, options?: import('better-auth').ClientFetchOption | undefined) => Promise<{
+                    data: null;
+                    error: {
+                        message?: string | undefined;
+                        status: number;
+                        statusText: string;
+                    };
+                } | {
+                    data: {
+                        session: 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;
+            };
+        };
+        getAtoms($fetch: import('better-auth/client').BetterFetch): {
+            listPasskeys: import('better-auth/client').AuthQueryAtom<import('@better-auth/passkey/client').Passkey[]>;
+            $listPasskeys: import('better-auth/client').PreinitializedWritableAtom<any> & object;
+        };
+        pathMethods: {
+            "/passkey/register": "POST";
+            "/passkey/authenticate": "POST";
+        };
+        atomListeners: ({
+            matcher(path: string): path is "/passkey/delete-passkey" | "/passkey/update-passkey" | "/passkey/verify-registration" | "/sign-out";
+            signal: "$listPasskeys";
+        } | {
+            matcher: (path: string) => path is "/passkey/verify-authentication";
+            signal: "$sessionSignal";
+        })[];
+        $ERROR_CODES: {
+            CHALLENGE_NOT_FOUND: import('better-auth').RawError<"CHALLENGE_NOT_FOUND">;
+            YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: import('better-auth').RawError<"YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY">;
+            FAILED_TO_VERIFY_REGISTRATION: import('better-auth').RawError<"FAILED_TO_VERIFY_REGISTRATION">;
+            PASSKEY_NOT_FOUND: import('better-auth').RawError<"PASSKEY_NOT_FOUND">;
+            AUTHENTICATION_FAILED: import('better-auth').RawError<"AUTHENTICATION_FAILED">;
+            UNABLE_TO_CREATE_SESSION: import('better-auth').RawError<"UNABLE_TO_CREATE_SESSION">;
+            FAILED_TO_UPDATE_PASSKEY: import('better-auth').RawError<"FAILED_TO_UPDATE_PASSKEY">;
+            PREVIOUSLY_REGISTERED: import('better-auth').RawError<"PREVIOUSLY_REGISTERED">;
+            REGISTRATION_CANCELLED: import('better-auth').RawError<"REGISTRATION_CANCELLED">;
+            AUTH_CANCELLED: import('better-auth').RawError<"AUTH_CANCELLED">;
+            UNKNOWN_ERROR: import('better-auth').RawError<"UNKNOWN_ERROR">;
+            SESSION_REQUIRED: import('better-auth').RawError<"SESSION_REQUIRED">;
+            RESOLVE_USER_REQUIRED: import('better-auth').RawError<"RESOLVE_USER_REQUIRED">;
+            RESOLVED_USER_INVALID: import('better-auth').RawError<"RESOLVED_USER_INVALID">;
+        };
+    } | {
+        id: "username";
+        version: string;
+        $InferServerPlugin: ReturnType<(options?: import('better-auth/plugins/username').UsernameOptions | undefined) => {
+            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">;
+                UNEXPECTED_ERROR: import('better-auth').RawError<"UNEXPECTED_ERROR">;
+                INVALID_USERNAME_OR_PASSWORD: import('better-auth').RawError<"INVALID_USERNAME_OR_PASSWORD">;
+                USERNAME_IS_ALREADY_TAKEN: import('better-auth').RawError<"USERNAME_IS_ALREADY_TAKEN">;
+                USERNAME_TOO_SHORT: import('better-auth').RawError<"USERNAME_TOO_SHORT">;
+                USERNAME_TOO_LONG: import('better-auth').RawError<"USERNAME_TOO_LONG">;
+                INVALID_USERNAME: import('better-auth').RawError<"INVALID_USERNAME">;
+                INVALID_DISPLAY_USERNAME: import('better-auth').RawError<"INVALID_DISPLAY_USERNAME">;
+            };
+        }>;
+        atomListeners: {
+            matcher: (path: string) => path is "/sign-in/username";
+            signal: "$sessionSignal";
+        }[];
+        $ERROR_CODES: {
+            EMAIL_NOT_VERIFIED: import('better-auth').RawError<"EMAIL_NOT_VERIFIED">;
+            UNEXPECTED_ERROR: import('better-auth').RawError<"UNEXPECTED_ERROR">;
+            INVALID_USERNAME_OR_PASSWORD: import('better-auth').RawError<"INVALID_USERNAME_OR_PASSWORD">;
+            USERNAME_IS_ALREADY_TAKEN: import('better-auth').RawError<"USERNAME_IS_ALREADY_TAKEN">;
+            USERNAME_TOO_SHORT: import('better-auth').RawError<"USERNAME_TOO_SHORT">;
+            USERNAME_TOO_LONG: import('better-auth').RawError<"USERNAME_TOO_LONG">;
+            INVALID_USERNAME: import('better-auth').RawError<"INVALID_USERNAME">;
+            INVALID_DISPLAY_USERNAME: import('better-auth').RawError<"INVALID_DISPLAY_USERNAME">;
+        };
+    })[];
+}, import('better-auth').ClientFetchOption<Partial<Partial<{}> & {
+    name?: string | undefined;
+    image?: string | undefined | null;
+}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>>, unknown>;