@better-auth-ui/react 1.6.0 → 1.6.1

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

@@ -280,6 +280,750 @@ export declare function useSignUpEmail(options?: UseAuthMutationOptions<AuthClie
         $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/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;