@b3dotfun/sdk 0.1.69 → 0.1.70-alpha.10

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

@@ -0,0 +1,2608 @@
+export type BetterAuthSocialProvider = "google" | "discord" | "apple" | "github" | "slack" | "microsoft";
+/** Thrown when email verification is required before the user can sign in. */
+export declare class EmailVerificationRequiredError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Hook for authentication via Better Auth (email/password + social providers).
+ *
+ * Follows the same pattern as Thirdweb auth:
+ * 1. Better Auth sign-in returns a session token
+ * 2. Token is passed as accessToken to app.authenticate({ strategy: "better-auth" })
+ * 3. BetterAuthStrategy verifies the token and issues a Feathers JWT
+ */
+export declare function useBetterAuth(): {
+    signInWithEmail: (email: string, password: string) => Promise<Record<string, any>>;
+    signUpWithEmail: (email: string, password: string, name: string, verifyCallbackURL?: string) => Promise<Record<string, any>>;
+    signInWithSocial: (provider: BetterAuthSocialProvider) => Promise<void>;
+    requestPasswordReset: (email: string, redirectTo?: string) => Promise<{
+        data: {
+            status: boolean;
+            message: string;
+        };
+        error: null;
+    }>;
+    resetPassword: (newPassword: string, token: string) => Promise<{
+        data: {
+            status: boolean;
+        };
+        error: null;
+    }>;
+    exchangeForFeathersJWT: (sessionToken: string) => Promise<Record<string, any>>;
+    betterAuthClient: {
+        twoFactor: {
+            enable: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                password?: string | undefined;
+                issuer?: string | undefined;
+            } | {
+                password: string;
+                issuer?: string | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<({
+                password?: string | undefined;
+                issuer?: string | undefined;
+            } | {
+                password: string;
+                issuer?: string | undefined;
+            }) & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                totpURI: string;
+                backupCodes: string[];
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            disable: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                password?: string | undefined;
+            } | {
+                password: string;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<({
+                password?: string | undefined;
+            } | {
+                password: string;
+            }) & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                status: boolean;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            verifyBackupCode: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                code: string;
+                disableSession?: boolean | undefined;
+                trustDevice?: boolean | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+                code: string;
+                disableSession?: boolean | undefined;
+                trustDevice?: boolean | undefined;
+            } & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<Omit<{
+                token: string | undefined;
+                user: (Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                }) | import("better-auth/plugins/two-factor").UserWithTwoFactor;
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            generateBackupCodes: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                password?: string | undefined;
+            } | {
+                password: string;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<({
+                password?: string | undefined;
+            } | {
+                password: string;
+            }) & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                status: boolean;
+                backupCodes: string[];
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            sendOtp: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                trustDevice?: boolean | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth/client").Prettify<{
+                query?: Record<string, any> | undefined;
+                fetchOptions?: FetchOptions | undefined;
+            }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                status: boolean;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            verifyOtp: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                code: string;
+                trustDevice?: boolean | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+                code: string;
+                trustDevice?: boolean | undefined;
+            } & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<(Omit<{
+                token: string;
+                user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }) | (Omit<{
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }), {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            getTotpUri: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                password?: string | undefined;
+            } | {
+                password: string;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<({
+                password?: string | undefined;
+            } | {
+                password: string;
+            }) & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                totpURI: string;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        twoFactor: {
+            verifyTotp: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                code: string;
+                trustDevice?: boolean | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+                code: string;
+                trustDevice?: boolean | undefined;
+            } & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<(Omit<{
+                token: string;
+                user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }) | (Omit<{
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }, "user"> & {
+                user: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    twoFactorEnabled: boolean | null | undefined;
+                } & {}>;
+            }), {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        signIn: {
+            social: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                provider: (string & {}) | "apple" | "google" | "github" | "discord" | "line" | "facebook" | "twitch" | "tiktok" | "zoom" | "linear" | "huggingface" | "atlassian" | "cognito" | "figma" | "microsoft" | "slack" | "spotify" | "twitter" | "dropbox" | "kick" | "linkedin" | "gitlab" | "reddit" | "roblox" | "salesforce" | "vk" | "notion" | "kakao" | "naver" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
+                callbackURL?: string | undefined;
+                newUserCallbackURL?: string | undefined;
+                errorCallbackURL?: string | undefined;
+                disableRedirect?: boolean | undefined;
+                idToken?: {
+                    token: string;
+                    nonce?: string | undefined;
+                    accessToken?: string | undefined;
+                    refreshToken?: string | undefined;
+                    expiresAt?: number | undefined;
+                    user?: {
+                        name?: {
+                            firstName?: string | undefined;
+                            lastName?: string | undefined;
+                        } | undefined;
+                        email?: string | undefined;
+                    } | undefined;
+                } | undefined;
+                scopes?: string[] | undefined;
+                requestSignUp?: boolean | undefined;
+                loginHint?: string | undefined;
+                additionalData?: Record<string, any> | undefined;
+            }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+                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";
+                callbackURL?: string | undefined;
+                newUserCallbackURL?: string | undefined;
+                errorCallbackURL?: string | undefined;
+                disableRedirect?: boolean | undefined;
+                idToken?: {
+                    token: string;
+                    nonce?: string | undefined;
+                    accessToken?: string | undefined;
+                    refreshToken?: string | undefined;
+                    expiresAt?: number | undefined;
+                    user?: {
+                        name?: {
+                            firstName?: string | undefined;
+                            lastName?: string | undefined;
+                        } | undefined;
+                        email?: string | undefined;
+                    } | undefined;
+                } | undefined;
+                scopes?: string[] | undefined;
+                requestSignUp?: boolean | undefined;
+                loginHint?: string | undefined;
+                additionalData?: Record<string, any> | undefined;
+            } & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                redirect: boolean;
+                url: string;
+            } | (Omit<{
+                redirect: boolean;
+                token: string;
+                url: undefined;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined | 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>>;
+        };
+    } & {
+        signOut: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, 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<{
+            success: boolean;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        signUp: {
+            email: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                name: string;
+                email: string;
+                password: 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<import("better-auth/client").InferSignUpEmailCtx<{
+                baseURL: string;
+                basePath: string;
+                fetchOptions: {
+                    credentials: "include";
+                };
+                plugins: {
+                    id: "two-factor";
+                    version: string;
+                    $InferServerPlugin: ReturnType<(<O extends import("better-auth/plugins/two-factor").TwoFactorOptions>(options?: O) => {
+                        id: "two-factor";
+                        version: string;
+                        endpoints: {
+                            enableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/enable", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                    password: import("zod").ZodString;
+                                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip>;
+                                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                    session: {
+                                        session: Record<string, any> & {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            userId: string;
+                                            expiresAt: Date;
+                                            token: string;
+                                            ipAddress?: string | null | undefined;
+                                            userAgent?: string | null | undefined;
+                                        };
+                                        user: Record<string, any> & {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            email: string;
+                                            emailVerified: boolean;
+                                            name: string;
+                                            image?: string | null | undefined;
+                                        };
+                                    };
+                                }>)[];
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                totpURI: {
+                                                                    type: string;
+                                                                    description: string;
+                                                                };
+                                                                backupCodes: {
+                                                                    type: string;
+                                                                    items: {
+                                                                        type: string;
+                                                                    };
+                                                                    description: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                totpURI: string;
+                                backupCodes: string[];
+                            }>;
+                            disableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/disable", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                    password: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>;
+                                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                    session: {
+                                        session: Record<string, any> & {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            userId: string;
+                                            expiresAt: Date;
+                                            token: string;
+                                            ipAddress?: string | null | undefined;
+                                            userAgent?: string | null | undefined;
+                                        };
+                                        user: Record<string, any> & {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            email: string;
+                                            emailVerified: boolean;
+                                            name: string;
+                                            image?: string | null | undefined;
+                                        };
+                                    };
+                                }>)[];
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                status: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                status: boolean;
+                            }>;
+                            verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    code: import("zod").ZodString;
+                                    disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                }, import("zod/v4/core").$strip>;
+                                metadata: {
+                                    openapi: {
+                                        description: string;
+                                        responses: {
+                                            "200": {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                user: {
+                                                                    type: string;
+                                                                    properties: {
+                                                                        id: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        email: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        emailVerified: {
+                                                                            type: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        name: {
+                                                                            type: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        image: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        twoFactorEnabled: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        createdAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                        updatedAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                    };
+                                                                    required: string[];
+                                                                    description: string;
+                                                                };
+                                                                session: {
+                                                                    type: string;
+                                                                    properties: {
+                                                                        token: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        userId: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        createdAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                        expiresAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                    };
+                                                                    required: string[];
+                                                                    description: string;
+                                                                };
+                                                            };
+                                                            required: string[];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                token: string | undefined;
+                                user: (Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                }) | import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                            }>;
+                            generateBackupCodes: import("better-call").StrictEndpoint<"/two-factor/generate-backup-codes", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                    password: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>;
+                                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                    session: {
+                                        session: Record<string, any> & {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            userId: string;
+                                            expiresAt: Date;
+                                            token: string;
+                                            ipAddress?: string | null | undefined;
+                                            userAgent?: string | null | undefined;
+                                        };
+                                        user: Record<string, any> & {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            email: string;
+                                            emailVerified: boolean;
+                                            name: string;
+                                            image?: string | null | undefined;
+                                        };
+                                    };
+                                }>)[];
+                                metadata: {
+                                    openapi: {
+                                        description: string;
+                                        responses: {
+                                            "200": {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                status: {
+                                                                    type: string;
+                                                                    description: string;
+                                                                    enum: boolean[];
+                                                                };
+                                                                backupCodes: {
+                                                                    type: string;
+                                                                    items: {
+                                                                        type: string;
+                                                                    };
+                                                                    description: string;
+                                                                };
+                                                            };
+                                                            required: string[];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                status: boolean;
+                                backupCodes: string[];
+                            }>;
+                            viewBackupCodes: import("better-call").StrictEndpoint<string, {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    userId: import("zod").ZodCoercedString<unknown>;
+                                }, import("zod/v4/core").$strip>;
+                            }, {
+                                status: boolean;
+                                backupCodes: string[];
+                            }>;
+                            sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
+                                method: "POST";
+                                body: import("zod").ZodOptional<import("zod").ZodObject<{
+                                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                }, import("zod/v4/core").$strip>>;
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                status: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                status: boolean;
+                            }>;
+                            verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    code: import("zod").ZodString;
+                                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                }, import("zod/v4/core").$strip>;
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            "200": {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                token: {
+                                                                    type: string;
+                                                                    description: string;
+                                                                };
+                                                                user: {
+                                                                    type: string;
+                                                                    properties: {
+                                                                        id: {
+                                                                            type: string;
+                                                                            description: string;
+                                                                        };
+                                                                        email: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        emailVerified: {
+                                                                            type: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        name: {
+                                                                            type: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        image: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            nullable: boolean;
+                                                                            description: string;
+                                                                        };
+                                                                        createdAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                        updatedAt: {
+                                                                            type: string;
+                                                                            format: string;
+                                                                            description: string;
+                                                                        };
+                                                                    };
+                                                                    required: string[];
+                                                                    description: string;
+                                                                };
+                                                            };
+                                                            required: string[];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                token: string;
+                                user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                            } | {
+                                token: string;
+                                user: Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                            generateTOTP: import("better-call").StrictEndpoint<string, {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    secret: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>;
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                code: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                code: string;
+                            }>;
+                            getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
+                                method: "POST";
+                                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                    session: {
+                                        session: Record<string, any> & {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            userId: string;
+                                            expiresAt: Date;
+                                            token: string;
+                                            ipAddress?: string | null | undefined;
+                                            userAgent?: string | null | undefined;
+                                        };
+                                        user: Record<string, any> & {
+                                            id: string;
+                                            createdAt: Date;
+                                            updatedAt: Date;
+                                            email: string;
+                                            emailVerified: boolean;
+                                            name: string;
+                                            image?: string | null | undefined;
+                                        };
+                                    };
+                                }>)[];
+                                body: import("zod").ZodObject<{
+                                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                    password: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>;
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                totpURI: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                totpURI: string;
+                            }>;
+                            verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
+                                method: "POST";
+                                body: import("zod").ZodObject<{
+                                    code: import("zod").ZodString;
+                                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                }, import("zod/v4/core").$strip>;
+                                metadata: {
+                                    openapi: {
+                                        summary: string;
+                                        description: string;
+                                        responses: {
+                                            200: {
+                                                description: string;
+                                                content: {
+                                                    "application/json": {
+                                                        schema: {
+                                                            type: "object";
+                                                            properties: {
+                                                                status: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }, {
+                                token: string;
+                                user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                            } | {
+                                token: string;
+                                user: Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                        };
+                        options: NoInfer<O>;
+                        hooks: {
+                            after: {
+                                matcher(context: import("@better-auth/core").HookEndpointContext): boolean;
+                                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                    twoFactorRedirect: boolean;
+                                    twoFactorMethods: string[];
+                                } | undefined>;
+                            }[];
+                        };
+                        schema: {
+                            user: {
+                                fields: {
+                                    twoFactorEnabled: {
+                                        type: "boolean";
+                                        required: false;
+                                        defaultValue: false;
+                                        input: false;
+                                    };
+                                };
+                            };
+                            twoFactor: {
+                                fields: {
+                                    secret: {
+                                        type: "string";
+                                        required: true;
+                                        returned: false;
+                                        index: true;
+                                    };
+                                    backupCodes: {
+                                        type: "string";
+                                        required: true;
+                                        returned: false;
+                                    };
+                                    userId: {
+                                        type: "string";
+                                        required: true;
+                                        returned: false;
+                                        references: {
+                                            model: string;
+                                            field: string;
+                                        };
+                                        index: true;
+                                    };
+                                    verified: {
+                                        type: "boolean";
+                                        required: false;
+                                        defaultValue: true;
+                                        input: false;
+                                    };
+                                };
+                            };
+                        };
+                        rateLimit: {
+                            pathMatcher(path: string): boolean;
+                            window: number;
+                            max: number;
+                        }[];
+                        $ERROR_CODES: {
+                            OTP_NOT_ENABLED: import("better-auth/*").RawError<"OTP_NOT_ENABLED">;
+                            OTP_HAS_EXPIRED: import("better-auth/*").RawError<"OTP_HAS_EXPIRED">;
+                            TOTP_NOT_ENABLED: import("better-auth/*").RawError<"TOTP_NOT_ENABLED">;
+                            TWO_FACTOR_NOT_ENABLED: import("better-auth/*").RawError<"TWO_FACTOR_NOT_ENABLED">;
+                            BACKUP_CODES_NOT_ENABLED: import("better-auth/*").RawError<"BACKUP_CODES_NOT_ENABLED">;
+                            INVALID_BACKUP_CODE: import("better-auth/*").RawError<"INVALID_BACKUP_CODE">;
+                            INVALID_CODE: import("better-auth/*").RawError<"INVALID_CODE">;
+                            TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth/*").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+                            INVALID_TWO_FACTOR_COOKIE: import("better-auth/*").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+                        };
+                    })>;
+                    atomListeners: {
+                        matcher: (path: string) => boolean;
+                        signal: "$sessionSignal";
+                    }[];
+                    pathMethods: {
+                        "/two-factor/disable": "POST";
+                        "/two-factor/enable": "POST";
+                        "/two-factor/send-otp": "POST";
+                        "/two-factor/generate-backup-codes": "POST";
+                        "/two-factor/get-totp-uri": "POST";
+                        "/two-factor/verify-totp": "POST";
+                        "/two-factor/verify-otp": "POST";
+                        "/two-factor/verify-backup-code": "POST";
+                    };
+                    fetchPlugins: {
+                        id: string;
+                        name: string;
+                        hooks: {
+                            onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): Promise<void>;
+                        };
+                    }[];
+                    $ERROR_CODES: {
+                        OTP_NOT_ENABLED: import("better-auth/*").RawError<"OTP_NOT_ENABLED">;
+                        OTP_HAS_EXPIRED: import("better-auth/*").RawError<"OTP_HAS_EXPIRED">;
+                        TOTP_NOT_ENABLED: import("better-auth/*").RawError<"TOTP_NOT_ENABLED">;
+                        TWO_FACTOR_NOT_ENABLED: import("better-auth/*").RawError<"TWO_FACTOR_NOT_ENABLED">;
+                        BACKUP_CODES_NOT_ENABLED: import("better-auth/*").RawError<"BACKUP_CODES_NOT_ENABLED">;
+                        INVALID_BACKUP_CODE: import("better-auth/*").RawError<"INVALID_BACKUP_CODE">;
+                        INVALID_CODE: import("better-auth/*").RawError<"INVALID_CODE">;
+                        TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth/*").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+                        INVALID_TWO_FACTOR_COOKIE: import("better-auth/*").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+                    };
+                }[];
+            }, FetchOptions>>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<(Omit<{
+                token: null;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined | 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;
+                } & {}>;
+            }) | (Omit<{
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined | 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: {
+            email: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+                email: string;
+                password: string;
+                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;
+                password: string;
+                callbackURL?: string | undefined;
+                rememberMe?: boolean | undefined;
+            } & {
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<Omit<{
+                redirect: boolean;
+                token: string;
+                url?: string | undefined;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined | 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>>;
+        };
+    } & {
+        resetPassword: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            newPassword: string;
+            token?: string | undefined;
+        }> & Record<string, any>, Partial<{
+            token?: string | undefined;
+        }> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            newPassword: string;
+            token?: string | undefined;
+        } & {
+            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>>;
+    } & {
+        verifyEmail: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, Partial<{
+            token: string;
+            callbackURL?: string | undefined;
+        }> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            query: {
+                token: string;
+                callbackURL?: string | undefined;
+            };
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<NonNullable<void | {
+            status: boolean;
+        }>, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        sendVerificationEmail: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            email: string;
+            callbackURL?: string | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            email: string;
+            callbackURL?: string | undefined;
+        } & {
+            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>>;
+    } & {
+        changeEmail: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            newEmail: string;
+            callbackURL?: string | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            newEmail: string;
+            callbackURL?: string | undefined;
+        } & {
+            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>>;
+    } & {
+        changePassword: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            newPassword: string;
+            currentPassword: string;
+            revokeOtherSessions?: boolean | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            newPassword: string;
+            currentPassword: string;
+            revokeOtherSessions?: boolean | undefined;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<Omit<{
+            token: string | null;
+            user: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+            } & 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>>;
+    } & {
+        updateSession: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<Partial<{}>> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth/client").Prettify<Partial<{}> & {
+            fetchOptions?: FetchOptions | undefined;
+        }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+            session: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+            };
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        updateUser: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<Partial<{}> & {
+            name?: string | undefined;
+            image?: string | undefined | null;
+        }> & 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").InferUserUpdateCtx<{
+            baseURL: string;
+            basePath: string;
+            fetchOptions: {
+                credentials: "include";
+            };
+            plugins: {
+                id: "two-factor";
+                version: string;
+                $InferServerPlugin: ReturnType<(<O extends import("better-auth/plugins/two-factor").TwoFactorOptions>(options?: O) => {
+                    id: "two-factor";
+                    version: string;
+                    endpoints: {
+                        enableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/enable", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                password: import("zod").ZodOptional<import("zod").ZodString>;
+                                issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                password: import("zod").ZodString;
+                                issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip>;
+                            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                session: {
+                                    session: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        userId: string;
+                                        expiresAt: Date;
+                                        token: string;
+                                        ipAddress?: string | null | undefined;
+                                        userAgent?: string | null | undefined;
+                                    };
+                                    user: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        email: string;
+                                        emailVerified: boolean;
+                                        name: string;
+                                        image?: string | null | undefined;
+                                    };
+                                };
+                            }>)[];
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            totpURI: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            backupCodes: {
+                                                                type: string;
+                                                                items: {
+                                                                    type: string;
+                                                                };
+                                                                description: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            totpURI: string;
+                            backupCodes: string[];
+                        }>;
+                        disableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/disable", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                password: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                password: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>;
+                            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                session: {
+                                    session: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        userId: string;
+                                        expiresAt: Date;
+                                        token: string;
+                                        ipAddress?: string | null | undefined;
+                                        userAgent?: string | null | undefined;
+                                    };
+                                    user: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        email: string;
+                                        emailVerified: boolean;
+                                        name: string;
+                                        image?: string | null | undefined;
+                                    };
+                                };
+                            }>)[];
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            status: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            status: boolean;
+                        }>;
+                        verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                code: import("zod").ZodString;
+                                disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strip>;
+                            metadata: {
+                                openapi: {
+                                    description: string;
+                                    responses: {
+                                        "200": {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            user: {
+                                                                type: string;
+                                                                properties: {
+                                                                    id: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    email: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    emailVerified: {
+                                                                        type: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    name: {
+                                                                        type: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    image: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    twoFactorEnabled: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    createdAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                    updatedAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                };
+                                                                required: string[];
+                                                                description: string;
+                                                            };
+                                                            session: {
+                                                                type: string;
+                                                                properties: {
+                                                                    token: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    userId: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    createdAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                    expiresAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                };
+                                                                required: string[];
+                                                                description: string;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            token: string | undefined;
+                            user: (Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            }) | import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                        }>;
+                        generateBackupCodes: import("better-call").StrictEndpoint<"/two-factor/generate-backup-codes", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                password: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                password: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>;
+                            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                session: {
+                                    session: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        userId: string;
+                                        expiresAt: Date;
+                                        token: string;
+                                        ipAddress?: string | null | undefined;
+                                        userAgent?: string | null | undefined;
+                                    };
+                                    user: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        email: string;
+                                        emailVerified: boolean;
+                                        name: string;
+                                        image?: string | null | undefined;
+                                    };
+                                };
+                            }>)[];
+                            metadata: {
+                                openapi: {
+                                    description: string;
+                                    responses: {
+                                        "200": {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            status: {
+                                                                type: string;
+                                                                description: string;
+                                                                enum: boolean[];
+                                                            };
+                                                            backupCodes: {
+                                                                type: string;
+                                                                items: {
+                                                                    type: string;
+                                                                };
+                                                                description: string;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            status: boolean;
+                            backupCodes: string[];
+                        }>;
+                        viewBackupCodes: import("better-call").StrictEndpoint<string, {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                userId: import("zod").ZodCoercedString<unknown>;
+                            }, import("zod/v4/core").$strip>;
+                        }, {
+                            status: boolean;
+                            backupCodes: string[];
+                        }>;
+                        sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
+                            method: "POST";
+                            body: import("zod").ZodOptional<import("zod").ZodObject<{
+                                trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strip>>;
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            status: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            status: boolean;
+                        }>;
+                        verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                code: import("zod").ZodString;
+                                trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strip>;
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        "200": {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            token: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            user: {
+                                                                type: string;
+                                                                properties: {
+                                                                    id: {
+                                                                        type: string;
+                                                                        description: string;
+                                                                    };
+                                                                    email: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    emailVerified: {
+                                                                        type: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    name: {
+                                                                        type: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    image: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        nullable: boolean;
+                                                                        description: string;
+                                                                    };
+                                                                    createdAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                    updatedAt: {
+                                                                        type: string;
+                                                                        format: string;
+                                                                        description: string;
+                                                                    };
+                                                                };
+                                                                required: string[];
+                                                                description: string;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            token: string;
+                            user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                        } | {
+                            token: string;
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        }>;
+                        generateTOTP: import("better-call").StrictEndpoint<string, {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                secret: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>;
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            code: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            code: string;
+                        }>;
+                        getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
+                            method: "POST";
+                            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                session: {
+                                    session: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        userId: string;
+                                        expiresAt: Date;
+                                        token: string;
+                                        ipAddress?: string | null | undefined;
+                                        userAgent?: string | null | undefined;
+                                    };
+                                    user: Record<string, any> & {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        email: string;
+                                        emailVerified: boolean;
+                                        name: string;
+                                        image?: string | null | undefined;
+                                    };
+                                };
+                            }>)[];
+                            body: import("zod").ZodObject<{
+                                password: import("zod").ZodOptional<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                                password: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>;
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            totpURI: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            totpURI: string;
+                        }>;
+                        verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
+                            method: "POST";
+                            body: import("zod").ZodObject<{
+                                code: import("zod").ZodString;
+                                trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strip>;
+                            metadata: {
+                                openapi: {
+                                    summary: string;
+                                    description: string;
+                                    responses: {
+                                        200: {
+                                            description: string;
+                                            content: {
+                                                "application/json": {
+                                                    schema: {
+                                                        type: "object";
+                                                        properties: {
+                                                            status: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        }, {
+                            token: string;
+                            user: import("better-auth/plugins/two-factor").UserWithTwoFactor;
+                        } | {
+                            token: string;
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        }>;
+                    };
+                    options: NoInfer<O>;
+                    hooks: {
+                        after: {
+                            matcher(context: import("@better-auth/core").HookEndpointContext): boolean;
+                            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                                twoFactorRedirect: boolean;
+                                twoFactorMethods: string[];
+                            } | undefined>;
+                        }[];
+                    };
+                    schema: {
+                        user: {
+                            fields: {
+                                twoFactorEnabled: {
+                                    type: "boolean";
+                                    required: false;
+                                    defaultValue: false;
+                                    input: false;
+                                };
+                            };
+                        };
+                        twoFactor: {
+                            fields: {
+                                secret: {
+                                    type: "string";
+                                    required: true;
+                                    returned: false;
+                                    index: true;
+                                };
+                                backupCodes: {
+                                    type: "string";
+                                    required: true;
+                                    returned: false;
+                                };
+                                userId: {
+                                    type: "string";
+                                    required: true;
+                                    returned: false;
+                                    references: {
+                                        model: string;
+                                        field: string;
+                                    };
+                                    index: true;
+                                };
+                                verified: {
+                                    type: "boolean";
+                                    required: false;
+                                    defaultValue: true;
+                                    input: false;
+                                };
+                            };
+                        };
+                    };
+                    rateLimit: {
+                        pathMatcher(path: string): boolean;
+                        window: number;
+                        max: number;
+                    }[];
+                    $ERROR_CODES: {
+                        OTP_NOT_ENABLED: import("better-auth/*").RawError<"OTP_NOT_ENABLED">;
+                        OTP_HAS_EXPIRED: import("better-auth/*").RawError<"OTP_HAS_EXPIRED">;
+                        TOTP_NOT_ENABLED: import("better-auth/*").RawError<"TOTP_NOT_ENABLED">;
+                        TWO_FACTOR_NOT_ENABLED: import("better-auth/*").RawError<"TWO_FACTOR_NOT_ENABLED">;
+                        BACKUP_CODES_NOT_ENABLED: import("better-auth/*").RawError<"BACKUP_CODES_NOT_ENABLED">;
+                        INVALID_BACKUP_CODE: import("better-auth/*").RawError<"INVALID_BACKUP_CODE">;
+                        INVALID_CODE: import("better-auth/*").RawError<"INVALID_CODE">;
+                        TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth/*").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+                        INVALID_TWO_FACTOR_COOKIE: import("better-auth/*").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+                    };
+                })>;
+                atomListeners: {
+                    matcher: (path: string) => boolean;
+                    signal: "$sessionSignal";
+                }[];
+                pathMethods: {
+                    "/two-factor/disable": "POST";
+                    "/two-factor/enable": "POST";
+                    "/two-factor/send-otp": "POST";
+                    "/two-factor/generate-backup-codes": "POST";
+                    "/two-factor/get-totp-uri": "POST";
+                    "/two-factor/verify-totp": "POST";
+                    "/two-factor/verify-otp": "POST";
+                    "/two-factor/verify-backup-code": "POST";
+                };
+                fetchPlugins: {
+                    id: string;
+                    name: string;
+                    hooks: {
+                        onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): Promise<void>;
+                    };
+                }[];
+                $ERROR_CODES: {
+                    OTP_NOT_ENABLED: import("better-auth/*").RawError<"OTP_NOT_ENABLED">;
+                    OTP_HAS_EXPIRED: import("better-auth/*").RawError<"OTP_HAS_EXPIRED">;
+                    TOTP_NOT_ENABLED: import("better-auth/*").RawError<"TOTP_NOT_ENABLED">;
+                    TWO_FACTOR_NOT_ENABLED: import("better-auth/*").RawError<"TWO_FACTOR_NOT_ENABLED">;
+                    BACKUP_CODES_NOT_ENABLED: import("better-auth/*").RawError<"BACKUP_CODES_NOT_ENABLED">;
+                    INVALID_BACKUP_CODE: import("better-auth/*").RawError<"INVALID_BACKUP_CODE">;
+                    INVALID_CODE: import("better-auth/*").RawError<"INVALID_CODE">;
+                    TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth/*").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+                    INVALID_TWO_FACTOR_COOKIE: import("better-auth/*").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+                };
+            }[];
+        }, FetchOptions>> | 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>>;
+    } & {
+        deleteUser: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            callbackURL?: string | undefined;
+            password?: string | undefined;
+            token?: string | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth/client").Prettify<{
+            callbackURL?: string | undefined;
+            password?: string | undefined;
+            token?: string | undefined;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+            success: boolean;
+            message: string;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        requestPasswordReset: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            email: string;
+            redirectTo?: string | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            email: string;
+            redirectTo?: string | undefined;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+            status: boolean;
+            message: string;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        resetPassword: {
+            ":token": <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, Partial<{
+                callbackURL: string;
+            }> & Record<string, any>, {
+                token: string;
+            }>>(data_0: import("better-auth/client").Prettify<{
+                query: {
+                    callbackURL: string;
+                };
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<never, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        listSessions: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, 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<import("better-auth/client").Prettify<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined | undefined;
+            userAgent?: string | null | undefined | undefined;
+        }>[], {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        revokeSession: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            token: string;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            token: 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>>;
+    } & {
+        revokeSessions: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, 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>>;
+    } & {
+        revokeOtherSessions: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, 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>>;
+    } & {
+        linkSocial: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            provider: unknown;
+            callbackURL?: string | undefined;
+            idToken?: {
+                token: string;
+                nonce?: string | undefined;
+                accessToken?: string | undefined;
+                refreshToken?: string | undefined;
+                scopes?: string[] | undefined;
+            } | undefined;
+            requestSignUp?: boolean | undefined;
+            scopes?: string[] | undefined;
+            errorCallbackURL?: string | undefined;
+            disableRedirect?: boolean | undefined;
+            additionalData?: Record<string, any> | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            provider: unknown;
+            callbackURL?: string | undefined;
+            idToken?: {
+                token: string;
+                nonce?: string | undefined;
+                accessToken?: string | undefined;
+                refreshToken?: string | undefined;
+                scopes?: string[] | undefined;
+            } | undefined;
+            requestSignUp?: boolean | undefined;
+            scopes?: string[] | undefined;
+            errorCallbackURL?: string | undefined;
+            disableRedirect?: boolean | undefined;
+            additionalData?: Record<string, any> | undefined;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+            url: string;
+            redirect: boolean;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        listAccounts: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, 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<{
+            scopes: string[];
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            providerId: string;
+            accountId: string;
+        }[], {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        deleteUser: {
+            callback: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, Partial<{
+                token: string;
+                callbackURL?: string | undefined;
+            }> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+                query: {
+                    token: string;
+                    callbackURL?: string | undefined;
+                };
+                fetchOptions?: FetchOptions | undefined;
+            }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+                success: boolean;
+                message: string;
+            }, {
+                code?: string | undefined;
+                message?: string | undefined;
+            }, FetchOptions["throw"] extends true ? true : false>>;
+        };
+    } & {
+        unlinkAccount: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            providerId: string;
+            accountId?: string | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            providerId: string;
+            accountId?: string | undefined;
+        } & {
+            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>>;
+    } & {
+        refreshToken: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            providerId: string;
+            accountId?: string | undefined;
+            userId?: string | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            providerId: string;
+            accountId?: string | undefined;
+            userId?: string | undefined;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+            accessToken: string | undefined;
+            refreshToken: string;
+            accessTokenExpiresAt: Date | undefined;
+            refreshTokenExpiresAt: Date | null | undefined;
+            scope: string | null | undefined;
+            idToken: string | null | undefined;
+            providerId: string;
+            accountId: string;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        getAccessToken: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
+            providerId: string;
+            accountId?: string | undefined;
+            userId?: string | undefined;
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/client").Prettify<{
+            providerId: string;
+            accountId?: string | undefined;
+            userId?: string | undefined;
+        } & {
+            fetchOptions?: FetchOptions | undefined;
+        }>, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+            accessToken: string;
+            accessTokenExpiresAt: Date | undefined;
+            scopes: string[];
+            idToken: string | undefined;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        accountInfo: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, Partial<{
+            accountId?: string | undefined;
+        }> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth/client").Prettify<{
+            query?: {
+                accountId?: string | undefined;
+            } | undefined;
+            fetchOptions?: FetchOptions | undefined;
+        }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+            user: import("better-auth/*").OAuth2UserInfo;
+            data: Record<string, any>;
+        }, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        getSession: <FetchOptions extends import("@better-auth/core").ClientFetchOption<never, Partial<{
+            disableCookieCache?: unknown;
+            disableRefresh?: unknown;
+        }> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth/client").Prettify<{
+            query?: {
+                disableCookieCache?: unknown;
+                disableRefresh?: unknown;
+            } | undefined;
+            fetchOptions?: FetchOptions | undefined;
+        }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+            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;
+            } & {}>;
+            session: import("better-auth/client").StripEmptyObjects<{
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+            }>;
+        } | null, {
+            code?: string | undefined;
+            message?: string | undefined;
+        }, FetchOptions["throw"] extends true ? true : false>>;
+    } & {
+        useSession: import("nanostores").Atom<{
+            data: {
+                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;
+                } & {}>;
+                session: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                }>;
+            } | null;
+            error: import("@better-fetch/fetch").BetterFetchError | null;
+            isPending: boolean;
+            isRefetching: boolean;
+            refetch: (queryParams?: {
+                query?: import("better-auth/client").SessionQueryParams;
+            } | undefined) => Promise<void>;
+        }>;
+        $fetch: import("@better-fetch/fetch").BetterFetch<{
+            plugins: (import("@better-fetch/fetch").BetterFetchPlugin<Record<string, any>> | {
+                id: string;
+                name: string;
+                hooks: {
+                    onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): void;
+                };
+            } | {
+                id: string;
+                name: string;
+                hooks: {
+                    onSuccess: ((context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void> | void) | undefined;
+                    onError: ((context: import("@better-fetch/fetch").ErrorContext) => Promise<void> | void) | undefined;
+                    onRequest: (<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>) => Promise<import("@better-fetch/fetch").RequestContext | void> | import("@better-fetch/fetch").RequestContext | void) | undefined;
+                    onResponse: ((context: import("@better-fetch/fetch").ResponseContext) => Promise<Response | void | import("@better-fetch/fetch").ResponseContext> | Response | import("@better-fetch/fetch").ResponseContext | void) | undefined;
+                };
+            })[];
+            priority?: RequestPriority | undefined;
+            cache?: RequestCache | undefined;
+            credentials?: RequestCredentials;
+            headers?: (HeadersInit & (HeadersInit | {
+                accept: "application/json" | "text/plain" | "application/octet-stream";
+                "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+                authorization: "Bearer" | "Basic";
+            })) | undefined;
+            integrity?: string | undefined;
+            keepalive?: boolean | undefined;
+            method: string;
+            mode?: RequestMode | undefined;
+            redirect?: RequestRedirect | undefined;
+            referrer?: string | undefined;
+            referrerPolicy?: ReferrerPolicy | undefined;
+            signal?: (AbortSignal | null) | undefined;
+            window?: null | undefined;
+            onRetry?: ((response: import("@better-fetch/fetch").ResponseContext) => Promise<void> | void) | undefined;
+            hookOptions?: {
+                cloneResponse?: boolean;
+            } | undefined;
+            timeout?: number | undefined;
+            customFetchImpl: import("@better-fetch/fetch").FetchEsque;
+            baseURL: string;
+            throw?: boolean | undefined;
+            auth?: ({
+                type: "Bearer";
+                token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+            } | {
+                type: "Basic";
+                username: string | (() => string | undefined) | undefined;
+                password: string | (() => string | undefined) | undefined;
+            } | {
+                type: "Custom";
+                prefix: string | (() => string | undefined) | undefined;
+                value: string | (() => string | undefined) | undefined;
+            }) | undefined;
+            body?: any;
+            query?: any;
+            params?: any;
+            duplex?: "full" | "half" | undefined;
+            jsonParser: (text: string) => Promise<any> | any;
+            retry?: import("@better-fetch/fetch").RetryOptions | undefined;
+            retryAttempt?: number | undefined;
+            output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+            errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
+            disableValidation?: boolean | undefined;
+            disableSignal?: boolean | undefined;
+        }, unknown, unknown, {}>;
+        $store: {
+            notify: (signal?: (Omit<string, "$sessionSignal"> | "$sessionSignal") | undefined) => void;
+            listen: (signal: Omit<string, "$sessionSignal"> | "$sessionSignal", listener: (value: boolean, oldValue?: boolean | undefined) => void) => void;
+            atoms: Record<string, import("nanostores").WritableAtom<any>>;
+        };
+        $Infer: {
+            Session: {
+                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;
+                } & {}>;
+                session: import("better-auth/client").StripEmptyObjects<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                }>;
+            };
+        };
+        $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;
+            };
+            FAILED_TO_CREATE_USER: {
+                readonly code: "FAILED_TO_CREATE_USER";
+                message: string;
+            };
+            FAILED_TO_CREATE_SESSION: {
+                readonly code: "FAILED_TO_CREATE_SESSION";
+                message: string;
+            };
+            FAILED_TO_UPDATE_USER: {
+                readonly code: "FAILED_TO_UPDATE_USER";
+                message: string;
+            };
+            FAILED_TO_GET_SESSION: {
+                readonly code: "FAILED_TO_GET_SESSION";
+                message: string;
+            };
+            INVALID_PASSWORD: {
+                readonly code: "INVALID_PASSWORD";
+                message: string;
+            };
+            INVALID_EMAIL: {
+                readonly code: "INVALID_EMAIL";
+                message: string;
+            };
+            INVALID_EMAIL_OR_PASSWORD: {
+                readonly code: "INVALID_EMAIL_OR_PASSWORD";
+                message: string;
+            };
+            INVALID_USER: {
+                readonly code: "INVALID_USER";
+                message: string;
+            };
+            SOCIAL_ACCOUNT_ALREADY_LINKED: {
+                readonly code: "SOCIAL_ACCOUNT_ALREADY_LINKED";
+                message: string;
+            };
+            PROVIDER_NOT_FOUND: {
+                readonly code: "PROVIDER_NOT_FOUND";
+                message: string;
+            };
+            INVALID_TOKEN: {
+                readonly code: "INVALID_TOKEN";
+                message: string;
+            };
+            TOKEN_EXPIRED: {
+                readonly code: "TOKEN_EXPIRED";
+                message: string;
+            };
+            ID_TOKEN_NOT_SUPPORTED: {
+                readonly code: "ID_TOKEN_NOT_SUPPORTED";
+                message: string;
+            };
+            FAILED_TO_GET_USER_INFO: {
+                readonly code: "FAILED_TO_GET_USER_INFO";
+                message: string;
+            };
+            USER_EMAIL_NOT_FOUND: {
+                readonly code: "USER_EMAIL_NOT_FOUND";
+                message: string;
+            };
+            EMAIL_NOT_VERIFIED: {
+                readonly code: "EMAIL_NOT_VERIFIED";
+                message: string;
+            };
+            PASSWORD_TOO_SHORT: {
+                readonly code: "PASSWORD_TOO_SHORT";
+                message: string;
+            };
+            PASSWORD_TOO_LONG: {
+                readonly code: "PASSWORD_TOO_LONG";
+                message: string;
+            };
+            USER_ALREADY_EXISTS: {
+                readonly code: "USER_ALREADY_EXISTS";
+                message: string;
+            };
+            USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: {
+                readonly code: "USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL";
+                message: string;
+            };
+            EMAIL_CAN_NOT_BE_UPDATED: {
+                readonly code: "EMAIL_CAN_NOT_BE_UPDATED";
+                message: string;
+            };
+            CREDENTIAL_ACCOUNT_NOT_FOUND: {
+                readonly code: "CREDENTIAL_ACCOUNT_NOT_FOUND";
+                message: string;
+            };
+            ACCOUNT_NOT_FOUND: {
+                readonly code: "ACCOUNT_NOT_FOUND";
+                message: string;
+            };
+            SESSION_EXPIRED: {
+                readonly code: "SESSION_EXPIRED";
+                message: string;
+            };
+            FAILED_TO_UNLINK_LAST_ACCOUNT: {
+                readonly code: "FAILED_TO_UNLINK_LAST_ACCOUNT";
+                message: string;
+            };
+            USER_ALREADY_HAS_PASSWORD: {
+                readonly code: "USER_ALREADY_HAS_PASSWORD";
+                message: string;
+            };
+            CROSS_SITE_NAVIGATION_LOGIN_BLOCKED: {
+                readonly code: "CROSS_SITE_NAVIGATION_LOGIN_BLOCKED";
+                message: string;
+            };
+            VERIFICATION_EMAIL_NOT_ENABLED: {
+                readonly code: "VERIFICATION_EMAIL_NOT_ENABLED";
+                message: string;
+            };
+            EMAIL_ALREADY_VERIFIED: {
+                readonly code: "EMAIL_ALREADY_VERIFIED";
+                message: string;
+            };
+            EMAIL_MISMATCH: {
+                readonly code: "EMAIL_MISMATCH";
+                message: string;
+            };
+            SESSION_NOT_FRESH: {
+                readonly code: "SESSION_NOT_FRESH";
+                message: string;
+            };
+            LINKED_ACCOUNT_ALREADY_EXISTS: {
+                readonly code: "LINKED_ACCOUNT_ALREADY_EXISTS";
+                message: string;
+            };
+            INVALID_ORIGIN: {
+                readonly code: "INVALID_ORIGIN";
+                message: string;
+            };
+            INVALID_CALLBACK_URL: {
+                readonly code: "INVALID_CALLBACK_URL";
+                message: string;
+            };
+            INVALID_REDIRECT_URL: {
+                readonly code: "INVALID_REDIRECT_URL";
+                message: string;
+            };
+            INVALID_ERROR_CALLBACK_URL: {
+                readonly code: "INVALID_ERROR_CALLBACK_URL";
+                message: string;
+            };
+            INVALID_NEW_USER_CALLBACK_URL: {
+                readonly code: "INVALID_NEW_USER_CALLBACK_URL";
+                message: string;
+            };
+            MISSING_OR_NULL_ORIGIN: {
+                readonly code: "MISSING_OR_NULL_ORIGIN";
+                message: string;
+            };
+            CALLBACK_URL_REQUIRED: {
+                readonly code: "CALLBACK_URL_REQUIRED";
+                message: string;
+            };
+            FAILED_TO_CREATE_VERIFICATION: {
+                readonly code: "FAILED_TO_CREATE_VERIFICATION";
+                message: string;
+            };
+            FIELD_NOT_ALLOWED: {
+                readonly code: "FIELD_NOT_ALLOWED";
+                message: string;
+            };
+            ASYNC_VALIDATION_NOT_SUPPORTED: {
+                readonly code: "ASYNC_VALIDATION_NOT_SUPPORTED";
+                message: string;
+            };
+            VALIDATION_ERROR: {
+                readonly code: "VALIDATION_ERROR";
+                message: string;
+            };
+            MISSING_FIELD: {
+                readonly code: "MISSING_FIELD";
+                message: string;
+            };
+            METHOD_NOT_ALLOWED_DEFER_SESSION_REQUIRED: {
+                readonly code: "METHOD_NOT_ALLOWED_DEFER_SESSION_REQUIRED";
+                message: string;
+            };
+            BODY_MUST_BE_AN_OBJECT: {
+                readonly code: "BODY_MUST_BE_AN_OBJECT";
+                message: string;
+            };
+            PASSWORD_ALREADY_SET: {
+                readonly code: "PASSWORD_ALREADY_SET";
+                message: string;
+            };
+        };
+    };
+};