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

package/dist/esm/global-account/better-auth-client.d.ts

@@ -1,5 +1,247 @@
 export type B3BetterAuthClient = ReturnType<typeof createB3BetterAuthClient>;
 export declare function createB3BetterAuthClient(baseURL?: string): {
+    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/client/plugins").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/client/plugins").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/client/plugins").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";
@@ -76,7 +318,9 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }), {
             code?: string | undefined;
             message?: string | undefined;
@@ -101,14 +345,684 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
             image?: string | undefined;
             callbackURL?: string | undefined;
             rememberMe?: boolean | undefined;
-        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/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/client/plugins").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/client/plugins").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/client/plugins").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/client/plugins").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;
@@ -128,7 +1042,9 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }) | (Omit<{
             token: string;
             user: {
@@ -149,7 +1065,9 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }), {
             code?: string | undefined;
             message?: string | undefined;
@@ -191,7 +1109,9 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }, {
             code?: string | undefined;
             message?: string | undefined;
@@ -299,7 +1219,9 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
             emailVerified: boolean;
             name: string;
             image?: string | null | undefined;
-        }>;
+        } & {
+            twoFactorEnabled: boolean | null | undefined;
+        } & {}>;
     }, {
         code?: string | undefined;
         message?: string | undefined;
@@ -332,6 +1254,677 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
         fetchOptions: {
             credentials: "include";
         };
+        plugins: {
+            id: "two-factor";
+            version: string;
+            $InferServerPlugin: ReturnType<(<O extends import("better-auth/client/plugins").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/client/plugins").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/client/plugins").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/client/plugins").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;
     }, {
@@ -581,7 +2174,7 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
         } | 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;
@@ -606,7 +2199,9 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
             emailVerified: boolean;
             name: string;
             image?: string | null | undefined;
-        }>;
+        } & {
+            twoFactorEnabled: boolean | null | undefined;
+        } & {}>;
         session: import("better-auth/client").StripEmptyObjects<{
             id: string;
             createdAt: Date;
@@ -632,7 +2227,9 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
             session: import("better-auth/client").StripEmptyObjects<{
                 id: string;
                 createdAt: Date;
@@ -668,8 +2265,8 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
                 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";
@@ -732,7 +2329,9 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
             session: import("better-auth/client").StripEmptyObjects<{
                 id: string;
                 createdAt: Date;
@@ -746,6 +2345,42 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
         };
     };
     $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;
@@ -940,7 +2575,257 @@ export declare function createB3BetterAuthClient(baseURL?: string): {
         };
     };
 };
+/** Get the shared BetterAuth client, creating it if needed. */
+export declare function getBetterAuthClient(): B3BetterAuthClient;
+/** Force-recreate the client on next access (e.g. after API URL change). */
+export declare function resetBetterAuthClient(): void;
+/**
+ * @deprecated Use `getBetterAuthClient()` instead. This static singleton
+ * does not reflect runtime API URL changes via `B3Provider apiUrl` prop.
+ */
 export declare const 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/client/plugins").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/client/plugins").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/client/plugins").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";
@@ -1017,7 +2902,9 @@ export declare const betterAuthClient: {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }), {
             code?: string | undefined;
             message?: string | undefined;
@@ -1042,14 +2929,684 @@ export declare const betterAuthClient: {
             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/client/plugins").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/client/plugins").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/client/plugins").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/client/plugins").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;
@@ -1069,7 +3626,9 @@ export declare const betterAuthClient: {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }) | (Omit<{
             token: string;
             user: {
@@ -1090,7 +3649,9 @@ export declare const betterAuthClient: {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }), {
             code?: string | undefined;
             message?: string | undefined;
@@ -1132,7 +3693,9 @@ export declare const betterAuthClient: {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
         }, {
             code?: string | undefined;
             message?: string | undefined;
@@ -1240,7 +3803,9 @@ export declare const betterAuthClient: {
             emailVerified: boolean;
             name: string;
             image?: string | null | undefined;
-        }>;
+        } & {
+            twoFactorEnabled: boolean | null | undefined;
+        } & {}>;
     }, {
         code?: string | undefined;
         message?: string | undefined;
@@ -1273,6 +3838,677 @@ export declare const betterAuthClient: {
         fetchOptions: {
             credentials: "include";
         };
+        plugins: {
+            id: "two-factor";
+            version: string;
+            $InferServerPlugin: ReturnType<(<O extends import("better-auth/client/plugins").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/client/plugins").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/client/plugins").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/client/plugins").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;
     }, {
@@ -1522,7 +4758,7 @@ export declare const betterAuthClient: {
         } | 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;
@@ -1547,7 +4783,9 @@ export declare const betterAuthClient: {
             emailVerified: boolean;
             name: string;
             image?: string | null | undefined;
-        }>;
+        } & {
+            twoFactorEnabled: boolean | null | undefined;
+        } & {}>;
         session: import("better-auth/client").StripEmptyObjects<{
             id: string;
             createdAt: Date;
@@ -1573,7 +4811,9 @@ export declare const betterAuthClient: {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
             session: import("better-auth/client").StripEmptyObjects<{
                 id: string;
                 createdAt: Date;
@@ -1609,8 +4849,8 @@ export declare const betterAuthClient: {
                 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";
@@ -1673,7 +4913,9 @@ export declare const betterAuthClient: {
                 emailVerified: boolean;
                 name: string;
                 image?: string | null | undefined;
-            }>;
+            } & {
+                twoFactorEnabled: boolean | null | undefined;
+            } & {}>;
             session: import("better-auth/client").StripEmptyObjects<{
                 id: string;
                 createdAt: Date;
@@ -1687,6 +4929,42 @@ export declare const betterAuthClient: {
         };
     };
     $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;