@b3dotfun/sdk 0.1.70-alpha.1 → 0.1.70-alpha.11

package/dist/esm/global-account/react/hooks/useBetterAuth.d.ts

@@ -12,8 +12,8 @@ export declare class EmailVerificationRequiredError extends Error {
  * 3. BetterAuthStrategy verifies the token and issues a Feathers JWT
  */
 export declare function useBetterAuth(): {
-    signInWithEmail: (email: string, password: string) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
-    signUpWithEmail: (email: string, password: string, name: string, verifyCallbackURL?: string) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    signInWithEmail: (email: string, password: string) => Promise<Record<string, any>>;
+    signUpWithEmail: (email: string, password: string, name: string, verifyCallbackURL?: string) => Promise<Record<string, any>>;
     signInWithSocial: (provider: BetterAuthSocialProvider) => Promise<void>;
     requestPasswordReset: (email: string, redirectTo?: string) => Promise<{
         data: {
@@ -28,8 +28,250 @@ export declare function useBetterAuth(): {
         };
         error: null;
     }>;
-    exchangeForFeathersJWT: (sessionToken: string) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    exchangeForFeathersJWT: (sessionToken: string) => Promise<Record<string, any>>;
     betterAuthClient: {
+        twoFactor: {
+            enable: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                password?: string | undefined;
+                issuer?: string | undefined;
+            } | {
+                password: string;
+                issuer?: string | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<({
+                password?: string | undefined;
+                issuer?: string | undefined;
+            } | {
+                password: string;
+                issuer?: string | undefined;
+            }) & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                totpURI: string;
+                backupCodes: string[];
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            disable: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                password?: string | undefined;
+            } | {
+                password: string;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<({
+                password?: string | undefined;
+            } | {
+                password: string;
+            }) & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                status: boolean;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            verifyBackupCode: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                code: string;
+                disableSession?: boolean | undefined;
+                trustDevice?: boolean | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+                code: string;
+                disableSession?: boolean | undefined;
+                trustDevice?: boolean | undefined;
+            } & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<Omit<{
+                token: string | undefined;
+                user: (Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                }) | import("better-auth/plugins/two-factor").UserWithTwoFactor;
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            generateBackupCodes: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                password?: string | undefined;
+            } | {
+                password: string;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<({
+                password?: string | undefined;
+            } | {
+                password: string;
+            }) & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                status: boolean;
+                backupCodes: string[];
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            sendOtp: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                trustDevice?: boolean | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth/client").Prettify<{
+                query?: Record<string, any> | undefined;
+                fetchOptions?: FetchOptions | undefined;
+            }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                status: boolean;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            verifyOtp: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                code: string;
+                trustDevice?: boolean | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+                code: string;
+                trustDevice?: boolean | undefined;
+            } & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<(Omit<{
+                token: string;
+                user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }) | (Omit<{
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }), {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            getTotpUri: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                password?: string | undefined;
+            } | {
+                password: string;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<({
+                password?: string | undefined;
+            } | {
+                password: string;
+            }) & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                totpURI: string;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            verifyTotp: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                code: string;
+                trustDevice?: boolean | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+                code: string;
+                trustDevice?: boolean | undefined;
+            } & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<(Omit<{
+                token: string;
+                user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }) | (Omit<{
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }), {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
         signIn: {
             social: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
                 provider: (string & {}) | "apple" | "google" | "github" | "discord" | "line" | "facebook" | "twitch" | "tiktok" | "zoom" | "linear" | "huggingface" | "atlassian" | "cognito" | "figma" | "microsoft" | "slack" | "spotify" | "twitter" | "dropbox" | "kick" | "linkedin" | "gitlab" | "reddit" | "roblox" | "salesforce" | "vk" | "notion" | "kakao" | "naver" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
@@ -106,7 +348,9 @@ export declare function useBetterAuth(): {
                     emailVerified: boolean;
                     name: string;
                     image?: string | null | undefined;
-                }>;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
             }), {
                 code?: string | undefined;
                 message?: string | undefined;
@@ -131,14 +375,684 @@ export declare function useBetterAuth(): {
                 image?: string | undefined;
                 callbackURL?: string | undefined;
                 rememberMe?: boolean | undefined;
-            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
-                email: string;
-                name: string;
-                password: string;
-                image?: string | undefined;
-                callbackURL?: string | undefined;
-                fetchOptions?: FetchOptions | undefined;
-            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<(Omit<{
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<import("better-auth/client").InferSignUpEmailCtx<{
+                baseURL: string;
+                basePath: string;
+                fetchOptions: {
+                    credentials: "include";
+                };
+                plugins: {
+                    id: "two-factor";
+                    version: string;
+                    $InferServerPlugin: ReturnType<(<O extends import("better-auth/plugins/two-factor").TwoFactorOptions>(options?: O) => {
+                        id: "two-factor";
+                        version: string;
+                        endpoints: {
+                            enableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/enable", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                    password: import("zod").ZodString;
+                                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip>;
+                                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                totpURI: {
+                                                                    type: string;
+                                                                    description: string;
+                                                                };
+                                                                backupCodes: {
+                                                                    type: string;
+                                                                    items: {
+                                                                        type: string;
+                                                                    };
+                                                                    description: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                totpURI: string;
+                                backupCodes: string[];
+                            }>;
+                            disableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/disable", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                    password: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>;
+                                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                status: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                status: boolean;
+                            }>;
+                            verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    code: import("zod").ZodString;
+                                    disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                }, import("zod/v4/core").$strip>;
+                                metadata: {
+                                    openapi: {
+                                        description: string;
+                                        responses: {
+                                            "200": {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                user: {
+                                                                    type: string;
+                                                                    properties: {
+                                                                        id: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        email: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        emailVerified: {
+                                                                            type: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        name: {
+                                                                            type: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        image: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        twoFactorEnabled: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        createdAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                        updatedAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                    };
+                                                                    required: string[];
+                                                                    description: string;
+                                                                };
+                                                                session: {
+                                                                    type: string;
+                                                                    properties: {
+                                                                        token: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        userId: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        createdAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                        expiresAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                    };
+                                                                    required: string[];
+                                                                    description: string;
+                                                                };
+                                                            };
+                                                            required: string[];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                token: string | undefined;
+                                user: (Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                }) | import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                            }>;
+                            generateBackupCodes: import("better-call").StrictEndpoint<"/two-factor/generate-backup-codes", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                    password: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>;
+                                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                                                                    description: string;
+                                                                    enum: boolean[];
+                                                                };
+                                                                backupCodes: {
+                                                                    type: string;
+                                                                    items: {
+                                                                        type: string;
+                                                                    };
+                                                                    description: string;
+                                                                };
+                                                            };
+                                                            required: string[];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                status: boolean;
+                                backupCodes: string[];
+                            }>;
+                            viewBackupCodes: import("better-call").StrictEndpoint<string, {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    userId: import("zod").ZodCoercedString<unknown>;
+                                }, import("zod/v4/core").$strip>;
+                            }, {
+                                status: boolean;
+                                backupCodes: string[];
+                            }>;
+                            sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
+                                method: "POST";
+                                body: import("zod").ZodOptional<import("zod").ZodObject<{
+                                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                }, import("zod/v4/core").$strip>>;
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                status: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                status: boolean;
+                            }>;
+                            verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    code: import("zod").ZodString;
+                                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                }, 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: {
+                                                                    type: string;
+                                                                    properties: {
+                                                                        id: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        email: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        emailVerified: {
+                                                                            type: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        name: {
+                                                                            type: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        image: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        createdAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                        updatedAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                    };
+                                                                    required: string[];
+                                                                    description: string;
+                                                                };
+                                                            };
+                                                            required: string[];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                token: string;
+                                user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                            } | {
+                                token: string;
+                                user: Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                            generateTOTP: import("better-call").StrictEndpoint<string, {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    secret: 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: {
+                                                                code: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                code: string;
+                            }>;
+                            getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
+                                method: "POST";
+                                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                                        };
+                                    };
+                                }>)[];
+                                body: import("zod").ZodObject<{
+                                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                    password: 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: {
+                                                                totpURI: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                totpURI: string;
+                            }>;
+                            verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    code: import("zod").ZodString;
+                                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                }, import("zod/v4/core").$strip>;
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                status: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                token: string;
+                                user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                            } | {
+                                token: string;
+                                user: Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                        };
+                        options: NoInfer<O>;
+                        hooks: {
+                            after: {
+                                matcher(context: import("@better-auth/core").HookEndpointContext): boolean;
+                                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                    twoFactorRedirect: boolean;
+                                    twoFactorMethods: string[];
+                                } | undefined>;
+                            }[];
+                        };
+                        schema: {
+                            user: {
+                                fields: {
+                                    twoFactorEnabled: {
+                                        type: "boolean";
+                                        required: false;
+                                        defaultValue: false;
+                                        input: false;
+                                    };
+                                };
+                            };
+                            twoFactor: {
+                                fields: {
+                                    secret: {
+                                        type: "string";
+                                        required: true;
+                                        returned: false;
+                                        index: true;
+                                    };
+                                    backupCodes: {
+                                        type: "string";
+                                        required: true;
+                                        returned: false;
+                                    };
+                                    userId: {
+                                        type: "string";
+                                        required: true;
+                                        returned: false;
+                                        references: {
+                                            model: string;
+                                            field: string;
+                                        };
+                                        index: true;
+                                    };
+                                    verified: {
+                                        type: "boolean";
+                                        required: false;
+                                        defaultValue: true;
+                                        input: false;
+                                    };
+                                };
+                            };
+                        };
+                        rateLimit: {
+                            pathMatcher(path: string): boolean;
+                            window: number;
+                            max: number;
+                        }[];
+                        $ERROR_CODES: {
+                            OTP_NOT_ENABLED: import("better-auth/*").RawError<"OTP_NOT_ENABLED">;
+                            OTP_HAS_EXPIRED: import("better-auth/*").RawError<"OTP_HAS_EXPIRED">;
+                            TOTP_NOT_ENABLED: import("better-auth/*").RawError<"TOTP_NOT_ENABLED">;
+                            TWO_FACTOR_NOT_ENABLED: import("better-auth/*").RawError<"TWO_FACTOR_NOT_ENABLED">;
+                            BACKUP_CODES_NOT_ENABLED: import("better-auth/*").RawError<"BACKUP_CODES_NOT_ENABLED">;
+                            INVALID_BACKUP_CODE: import("better-auth/*").RawError<"INVALID_BACKUP_CODE">;
+                            INVALID_CODE: import("better-auth/*").RawError<"INVALID_CODE">;
+                            TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth/*").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+                            INVALID_TWO_FACTOR_COOKIE: import("better-auth/*").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+                        };
+                    })>;
+                    atomListeners: {
+                        matcher: (path: string) => boolean;
+                        signal: "$sessionSignal";
+                    }[];
+                    pathMethods: {
+                        "/two-factor/disable": "POST";
+                        "/two-factor/enable": "POST";
+                        "/two-factor/send-otp": "POST";
+                        "/two-factor/generate-backup-codes": "POST";
+                        "/two-factor/get-totp-uri": "POST";
+                        "/two-factor/verify-totp": "POST";
+                        "/two-factor/verify-otp": "POST";
+                        "/two-factor/verify-backup-code": "POST";
+                    };
+                    fetchPlugins: {
+                        id: string;
+                        name: string;
+                        hooks: {
+                            onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): Promise<void>;
+                        };
+                    }[];
+                    $ERROR_CODES: {
+                        OTP_NOT_ENABLED: import("better-auth/*").RawError<"OTP_NOT_ENABLED">;
+                        OTP_HAS_EXPIRED: import("better-auth/*").RawError<"OTP_HAS_EXPIRED">;
+                        TOTP_NOT_ENABLED: import("better-auth/*").RawError<"TOTP_NOT_ENABLED">;
+                        TWO_FACTOR_NOT_ENABLED: import("better-auth/*").RawError<"TWO_FACTOR_NOT_ENABLED">;
+                        BACKUP_CODES_NOT_ENABLED: import("better-auth/*").RawError<"BACKUP_CODES_NOT_ENABLED">;
+                        INVALID_BACKUP_CODE: import("better-auth/*").RawError<"INVALID_BACKUP_CODE">;
+                        INVALID_CODE: import("better-auth/*").RawError<"INVALID_CODE">;
+                        TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth/*").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+                        INVALID_TWO_FACTOR_COOKIE: import("better-auth/*").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+                    };
+                }[];
+            }, FetchOptions>>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<(Omit<{
                 token: null;
                 user: {
                     id: string;
@@ -158,7 +1072,9 @@ export declare function useBetterAuth(): {
                     emailVerified: boolean;
                     name: string;
                     image?: string | null | undefined;
-                }>;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
             }) | (Omit<{
                 token: string;
                 user: {
@@ -179,7 +1095,9 @@ export declare function useBetterAuth(): {
                     emailVerified: boolean;
                     name: string;
                     image?: string | null | undefined;
-                }>;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
             }), {
                 code?: string | undefined;
                 message?: string | undefined;
@@ -221,7 +1139,9 @@ export declare function useBetterAuth(): {
                     emailVerified: boolean;
                     name: string;
                     image?: string | null | undefined;
-                }>;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
             }, {
                 code?: string | undefined;
                 message?: string | undefined;
@@ -329,7 +1249,9 @@ export declare function useBetterAuth(): {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }, {
             code?: string | undefined;
             message?: string | undefined;
@@ -362,6 +1284,677 @@ export declare function useBetterAuth(): {
             fetchOptions: {
                 credentials: "include";
             };
+            plugins: {
+                id: "two-factor";
+                version: string;
+                $InferServerPlugin: ReturnType<(<O extends import("better-auth/plugins/two-factor").TwoFactorOptions>(options?: O) => {
+                    id: "two-factor";
+                    version: string;
+                    endpoints: {
+                        enableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/enable", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                password: import("zod").ZodOptional<import("zod").ZodString>;
+                                issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                password: import("zod").ZodString;
+                                issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip>;
+                            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            totpURI: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            backupCodes: {
+                                                                type: string;
+                                                                items: {
+                                                                    type: string;
+                                                                };
+                                                                description: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            totpURI: string;
+                            backupCodes: string[];
+                        }>;
+                        disableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/disable", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                password: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                password: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>;
+                            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            status: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            status: boolean;
+                        }>;
+                        verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                code: import("zod").ZodString;
+                                disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strip>;
+                            metadata: {
+                                openapi: {
+                                    description: string;
+                                    responses: {
+                                        "200": {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            user: {
+                                                                type: string;
+                                                                properties: {
+                                                                    id: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    email: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    emailVerified: {
+                                                                        type: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    name: {
+                                                                        type: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    image: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    twoFactorEnabled: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    createdAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                    updatedAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                };
+                                                                required: string[];
+                                                                description: string;
+                                                            };
+                                                            session: {
+                                                                type: string;
+                                                                properties: {
+                                                                    token: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    userId: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    createdAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                    expiresAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                };
+                                                                required: string[];
+                                                                description: string;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            token: string | undefined;
+                            user: (Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            }) | import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                        }>;
+                        generateBackupCodes: import("better-call").StrictEndpoint<"/two-factor/generate-backup-codes", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                password: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                password: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>;
+                            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                                                                description: string;
+                                                                enum: boolean[];
+                                                            };
+                                                            backupCodes: {
+                                                                type: string;
+                                                                items: {
+                                                                    type: string;
+                                                                };
+                                                                description: string;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            status: boolean;
+                            backupCodes: string[];
+                        }>;
+                        viewBackupCodes: import("better-call").StrictEndpoint<string, {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                userId: import("zod").ZodCoercedString<unknown>;
+                            }, import("zod/v4/core").$strip>;
+                        }, {
+                            status: boolean;
+                            backupCodes: string[];
+                        }>;
+                        sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
+                            method: "POST";
+                            body: import("zod").ZodOptional<import("zod").ZodObject<{
+                                trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strip>>;
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            status: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            status: boolean;
+                        }>;
+                        verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                code: import("zod").ZodString;
+                                trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, 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: {
+                                                                type: string;
+                                                                properties: {
+                                                                    id: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    email: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    emailVerified: {
+                                                                        type: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    name: {
+                                                                        type: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    image: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    createdAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                    updatedAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                };
+                                                                required: string[];
+                                                                description: string;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            token: string;
+                            user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                        } | {
+                            token: string;
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        }>;
+                        generateTOTP: import("better-call").StrictEndpoint<string, {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                secret: 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: {
+                                                            code: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            code: string;
+                        }>;
+                        getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
+                            method: "POST";
+                            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                                    };
+                                };
+                            }>)[];
+                            body: import("zod").ZodObject<{
+                                password: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                password: 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: {
+                                                            totpURI: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            totpURI: string;
+                        }>;
+                        verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                code: import("zod").ZodString;
+                                trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strip>;
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            status: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            token: string;
+                            user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                        } | {
+                            token: string;
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        }>;
+                    };
+                    options: NoInfer<O>;
+                    hooks: {
+                        after: {
+                            matcher(context: import("@better-auth/core").HookEndpointContext): boolean;
+                            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                twoFactorRedirect: boolean;
+                                twoFactorMethods: string[];
+                            } | undefined>;
+                        }[];
+                    };
+                    schema: {
+                        user: {
+                            fields: {
+                                twoFactorEnabled: {
+                                    type: "boolean";
+                                    required: false;
+                                    defaultValue: false;
+                                    input: false;
+                                };
+                            };
+                        };
+                        twoFactor: {
+                            fields: {
+                                secret: {
+                                    type: "string";
+                                    required: true;
+                                    returned: false;
+                                    index: true;
+                                };
+                                backupCodes: {
+                                    type: "string";
+                                    required: true;
+                                    returned: false;
+                                };
+                                userId: {
+                                    type: "string";
+                                    required: true;
+                                    returned: false;
+                                    references: {
+                                        model: string;
+                                        field: string;
+                                    };
+                                    index: true;
+                                };
+                                verified: {
+                                    type: "boolean";
+                                    required: false;
+                                    defaultValue: true;
+                                    input: false;
+                                };
+                            };
+                        };
+                    };
+                    rateLimit: {
+                        pathMatcher(path: string): boolean;
+                        window: number;
+                        max: number;
+                    }[];
+                    $ERROR_CODES: {
+                        OTP_NOT_ENABLED: import("better-auth/*").RawError<"OTP_NOT_ENABLED">;
+                        OTP_HAS_EXPIRED: import("better-auth/*").RawError<"OTP_HAS_EXPIRED">;
+                        TOTP_NOT_ENABLED: import("better-auth/*").RawError<"TOTP_NOT_ENABLED">;
+                        TWO_FACTOR_NOT_ENABLED: import("better-auth/*").RawError<"TWO_FACTOR_NOT_ENABLED">;
+                        BACKUP_CODES_NOT_ENABLED: import("better-auth/*").RawError<"BACKUP_CODES_NOT_ENABLED">;
+                        INVALID_BACKUP_CODE: import("better-auth/*").RawError<"INVALID_BACKUP_CODE">;
+                        INVALID_CODE: import("better-auth/*").RawError<"INVALID_CODE">;
+                        TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth/*").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+                        INVALID_TWO_FACTOR_COOKIE: import("better-auth/*").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+                    };
+                })>;
+                atomListeners: {
+                    matcher: (path: string) => boolean;
+                    signal: "$sessionSignal";
+                }[];
+                pathMethods: {
+                    "/two-factor/disable": "POST";
+                    "/two-factor/enable": "POST";
+                    "/two-factor/send-otp": "POST";
+                    "/two-factor/generate-backup-codes": "POST";
+                    "/two-factor/get-totp-uri": "POST";
+                    "/two-factor/verify-totp": "POST";
+                    "/two-factor/verify-otp": "POST";
+                    "/two-factor/verify-backup-code": "POST";
+                };
+                fetchPlugins: {
+                    id: string;
+                    name: string;
+                    hooks: {
+                        onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): Promise<void>;
+                    };
+                }[];
+                $ERROR_CODES: {
+                    OTP_NOT_ENABLED: import("better-auth/*").RawError<"OTP_NOT_ENABLED">;
+                    OTP_HAS_EXPIRED: import("better-auth/*").RawError<"OTP_HAS_EXPIRED">;
+                    TOTP_NOT_ENABLED: import("better-auth/*").RawError<"TOTP_NOT_ENABLED">;
+                    TWO_FACTOR_NOT_ENABLED: import("better-auth/*").RawError<"TWO_FACTOR_NOT_ENABLED">;
+                    BACKUP_CODES_NOT_ENABLED: import("better-auth/*").RawError<"BACKUP_CODES_NOT_ENABLED">;
+                    INVALID_BACKUP_CODE: import("better-auth/*").RawError<"INVALID_BACKUP_CODE">;
+                    INVALID_CODE: import("better-auth/*").RawError<"INVALID_CODE">;
+                    TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth/*").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+                    INVALID_TWO_FACTOR_COOKIE: import("better-auth/*").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+                };
+            }[];
         }, FetchOptions>> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
             status: boolean;
         }, {
@@ -611,7 +2204,7 @@ export declare function useBetterAuth(): {
             } | undefined;
             fetchOptions?: FetchOptions | undefined;
         }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
-            user: import("@better-auth/core/oauth2").OAuth2UserInfo;
+            user: import("better-auth/*").OAuth2UserInfo;
             data: Record<string, any>;
         }, {
             code?: string | undefined;
@@ -636,7 +2229,9 @@ export declare function useBetterAuth(): {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
             session: import("better-auth/client").StripEmptyObjects<{
                 id: string;
                 createdAt: Date;
@@ -662,7 +2257,9 @@ export declare function useBetterAuth(): {
                     emailVerified: boolean;
                     name: string;
                     image?: string | null | undefined;
-                }>;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
                 session: import("better-auth/client").StripEmptyObjects<{
                     id: string;
                     createdAt: Date;
@@ -698,8 +2295,8 @@ export declare function useBetterAuth(): {
                     onResponse: ((context: import("@better-fetch/fetch").ResponseContext) => Promise<Response | void | import("@better-fetch/fetch").ResponseContext> | Response | import("@better-fetch/fetch").ResponseContext | void) | undefined;
                 };
             })[];
-            cache?: RequestCache | undefined;
             priority?: RequestPriority | undefined;
+            cache?: RequestCache | undefined;
             credentials?: RequestCredentials;
             headers?: (HeadersInit & (HeadersInit | {
                 accept: "application/json" | "text/plain" | "application/octet-stream";
@@ -762,7 +2359,9 @@ export declare function useBetterAuth(): {
                     emailVerified: boolean;
                     name: string;
                     image?: string | null | undefined;
-                }>;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
                 session: import("better-auth/client").StripEmptyObjects<{
                     id: string;
                     createdAt: Date;
@@ -776,6 +2375,42 @@ export declare function useBetterAuth(): {
             };
         };
         $ERROR_CODES: {
+            OTP_NOT_ENABLED: {
+                readonly code: "OTP_NOT_ENABLED";
+                message: string;
+            };
+            OTP_HAS_EXPIRED: {
+                readonly code: "OTP_HAS_EXPIRED";
+                message: string;
+            };
+            TOTP_NOT_ENABLED: {
+                readonly code: "TOTP_NOT_ENABLED";
+                message: string;
+            };
+            TWO_FACTOR_NOT_ENABLED: {
+                readonly code: "TWO_FACTOR_NOT_ENABLED";
+                message: string;
+            };
+            BACKUP_CODES_NOT_ENABLED: {
+                readonly code: "BACKUP_CODES_NOT_ENABLED";
+                message: string;
+            };
+            INVALID_BACKUP_CODE: {
+                readonly code: "INVALID_BACKUP_CODE";
+                message: string;
+            };
+            INVALID_CODE: {
+                readonly code: "INVALID_CODE";
+                message: string;
+            };
+            TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: {
+                readonly code: "TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE";
+                message: string;
+            };
+            INVALID_TWO_FACTOR_COOKIE: {
+                readonly code: "INVALID_TWO_FACTOR_COOKIE";
+                message: string;
+            };
             USER_NOT_FOUND: {
                 readonly code: "USER_NOT_FOUND";
                 message: string;