@nextsparkjs/core 0.1.0-beta.19 → 0.1.0-beta.191

package/dist/lib/auth-client.d.ts

@@ -1,2900 +1,1641 @@
-export declare const authClient: {
-    signIn: {
-        social: <FetchOptions extends {
-            method?: string;
-            mode?: RequestMode;
-            priority?: RequestPriority;
-            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";
-            });
-            cache?: RequestCache;
-            credentials?: RequestCredentials;
-            integrity?: string;
-            keepalive?: boolean;
-            redirect?: RequestRedirect;
-            referrer?: string;
-            referrerPolicy?: ReferrerPolicy;
-            signal?: AbortSignal | null;
-            window?: null;
-            next?: NextFetchRequestConfig | undefined;
-            onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-            onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-            onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-            onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-            onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-            hookOptions?: {
-                cloneResponse?: boolean;
+export declare const authClient: import("better-auth/react").ReactAuthClient<{
+    baseURL: string;
+    basePath: string;
+    plugins: ({
+        id: "additional-fields-client";
+        version: string;
+        $InferServerPlugin: {
+            id: "additional-fields";
+            version: string;
+            schema: {
+                user: {
+                    fields: {};
+                };
+                session: {
+                    fields: {};
+                };
             };
-            timeout?: number;
-            customFetchImpl?: import("better-auth/react").FetchEsque;
-            plugins?: import("better-auth/react").BetterFetchPlugin[];
-            baseURL?: string;
-            throw?: boolean;
-            auth?: {
-                type: "Bearer";
-                token: string | Promise<string> | (() => string | Promise<string>);
-            } | {
-                type: "Basic";
-                username: string | (() => string);
-                password: string | (() => string);
-            } | {
-                type: "Custom";
-                prefix: string | (() => string);
-                value: string | (() => string);
-            };
-            body?: Partial<{
-                provider: unknown;
-                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;
-                } | undefined;
-                scopes?: string[] | undefined;
-                requestSignUp?: boolean | undefined;
-                loginHint?: string | undefined;
-            }> & Record<string, any>;
-            query?: Partial<Record<string, any>> & Record<string, any>;
-            params?: Record<string, any>;
-            duplex?: "full" | "half";
-            jsonParser?: (text: string) => Promise<any> | any;
-            retry?: import("better-auth/react").RetryOptions;
-            retryAttempt?: number;
-            output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-            errorSchema?: import("better-auth/react").StandardSchemaV1;
-            disableValidation?: boolean;
-        }>(data_0: import("better-auth").Prettify<{
-            provider: unknown;
-            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;
+        };
+    } | {
+        id: "email-otp";
+        version: string;
+        $InferServerPlugin: ReturnType<(options: import("better-auth/plugins").EmailOTPOptions) => {
+            id: "email-otp";
+            version: string;
+            init(ctx: import("better-auth").AuthContext): {
+                options: {
+                    emailVerification: {
+                        sendVerificationEmail(data: {
+                            user: import("better-auth").User;
+                            url: string;
+                            token: string;
+                        }, request: Request | undefined): Promise<void>;
+                    };
+                };
             } | undefined;
-            scopes?: string[] | undefined;
-            requestSignUp?: boolean | undefined;
-            loginHint?: string | undefined;
-        } & {
-            fetchOptions?: FetchOptions;
-        }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<{
-            redirect: boolean;
-            token: string;
-            url: undefined;
-            user: {
-                id: string;
-                email: string;
-                name: string;
-                image: string | null | undefined;
-                emailVerified: boolean;
-                createdAt: Date;
-                updatedAt: Date;
+            endpoints: {
+                sendVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/send-verification-otp", {
+                    method: "POST";
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>[];
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        type: import("zod").ZodEnum<{
+                            "sign-in": "sign-in";
+                            "change-email": "change-email";
+                            "email-verification": "email-verification";
+                            "forget-password": "forget-password";
+                        }>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                createVerificationOTP: import("better-auth").StrictEndpoint<string, {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        type: import("zod").ZodEnum<{
+                            "sign-in": "sign-in";
+                            "change-email": "change-email";
+                            "email-verification": "email-verification";
+                            "forget-password": "forget-password";
+                        }>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "string";
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, string>;
+                getVerificationOTP: import("better-auth").StrictEndpoint<string, {
+                    method: "GET";
+                    query: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        type: import("zod").ZodEnum<{
+                            "sign-in": "sign-in";
+                            "change-email": "change-email";
+                            "email-verification": "email-verification";
+                            "forget-password": "forget-password";
+                        }>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    otp: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    otp: null;
+                } | {
+                    otp: string;
+                }>;
+                checkVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/check-verification-otp", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        type: import("zod").ZodEnum<{
+                            "sign-in": "sign-in";
+                            "change-email": "change-email";
+                            "email-verification": "email-verification";
+                            "forget-password": "forget-password";
+                        }>;
+                        otp: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                verifyEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/verify-email", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        otp: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    status: {
+                                                        type: string;
+                                                        description: string;
+                                                        enum: boolean[];
+                                                    };
+                                                    token: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    status: boolean;
+                    token: string;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    } & Record<string, any>;
+                } | {
+                    status: boolean;
+                    token: null;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    } & Record<string, any>;
+                }>;
+                signInEmailOTP: import("better-auth").StrictEndpoint<"/sign-in/email-otp", {
+                    method: "POST";
+                    body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        otp: import("zod").ZodString;
+                        name: import("zod").ZodOptional<import("zod").ZodString>;
+                        image: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    token: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    token: string;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                }>;
+                requestPasswordResetEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-password-reset", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                forgetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/forget-password/email-otp", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                resetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/reset-password", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        otp: import("zod").ZodString;
+                        password: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                requestEmailChangeEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-email-change", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        newEmail: import("zod").ZodString;
+                        otp: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                changeEmailEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/change-email", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        newEmail: import("zod").ZodString;
+                        otp: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
             };
-        } | {
-            url: string;
-            redirect: boolean;
-        }>, {
-            code?: string;
-            message?: string;
-        }, FetchOptions["throw"] extends true ? true : false>>;
-    };
-} & {
-    getSession: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<{
-            disableCookieCache?: unknown;
-            disableRefresh?: unknown;
-        }> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        user: {
-            id: string;
-            emailVerified: boolean;
-            name: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email?: string;
-            image?: string;
-        };
-        session: {
-            id: string;
-            userId: string;
-            expiresAt: Date;
-            createdAt: Date;
-            updatedAt: Date;
-            token: string;
-            ipAddress?: string;
-            userAgent?: string;
-        };
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    signOut: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        success: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    signIn: {
-        email: <FetchOptions extends {
-            method?: string;
-            mode?: RequestMode;
-            priority?: RequestPriority;
-            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";
-            });
-            cache?: RequestCache;
-            credentials?: RequestCredentials;
-            integrity?: string;
-            keepalive?: boolean;
-            redirect?: RequestRedirect;
-            referrer?: string;
-            referrerPolicy?: ReferrerPolicy;
-            signal?: AbortSignal | null;
-            window?: null;
-            next?: NextFetchRequestConfig | undefined;
-            onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-            onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-            onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-            onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-            onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-            hookOptions?: {
-                cloneResponse?: boolean;
+            hooks: {
+                after: {
+                    matcher(context: import("better-auth").HookEndpointContext): boolean;
+                    handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+                }[];
             };
-            timeout?: number;
-            customFetchImpl?: import("better-auth/react").FetchEsque;
-            plugins?: import("better-auth/react").BetterFetchPlugin[];
-            baseURL?: string;
-            throw?: boolean;
-            auth?: {
-                type: "Bearer";
-                token: string | Promise<string> | (() => string | Promise<string>);
+            rateLimit: ({
+                pathMatcher(path: string): path is "/email-otp/send-verification-otp";
+                window: number;
+                max: number;
             } | {
-                type: "Basic";
-                username: string | (() => string);
-                password: string | (() => string);
+                pathMatcher(path: string): path is "/email-otp/check-verification-otp";
+                window: number;
+                max: number;
             } | {
-                type: "Custom";
-                prefix: string | (() => string);
-                value: string | (() => string);
-            };
-            body?: Partial<{
-                email: string;
-                password: string;
-                callbackURL?: string | undefined;
-                rememberMe?: boolean | undefined;
-            }> & Record<string, any>;
-            query?: Partial<Record<string, any>> & Record<string, any>;
-            params?: Record<string, any>;
-            duplex?: "full" | "half";
-            jsonParser?: (text: string) => Promise<any> | any;
-            retry?: import("better-auth/react").RetryOptions;
-            retryAttempt?: number;
-            output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-            errorSchema?: import("better-auth/react").StandardSchemaV1;
-            disableValidation?: boolean;
-        }>(data_0: import("better-auth").Prettify<{
-            email: string;
-            password: string;
-            callbackURL?: string | undefined;
-            rememberMe?: boolean | undefined;
-        } & {
-            fetchOptions?: FetchOptions;
-        }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-            redirect: boolean;
-            token: string;
-            url: string | undefined;
-            user: {
-                id: string;
-                email: string;
-                name: string;
-                image: string | null | undefined;
-                emailVerified: boolean;
-                createdAt: Date;
-                updatedAt: Date;
-            };
-        }, {
-            code?: string;
-            message?: string;
-        }, FetchOptions["throw"] extends true ? true : false>>;
-    };
-} & {
-    forgetPassword: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            email: string;
-            redirectTo?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        email: string;
-        redirectTo?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    resetPassword: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            newPassword: string;
-            token?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<{
-            token?: string | undefined;
-        }> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        newPassword: string;
-        token?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    verifyEmail: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<{
-            token: string;
-            callbackURL?: string | undefined;
-        }> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<void | {
-        status: boolean;
-        user: {
-            id: any;
-            email: any;
-            name: any;
-            image: any;
-            emailVerified: any;
-            createdAt: any;
-            updatedAt: any;
-        };
-    } | {
-        status: boolean;
-        user: null;
-    }>, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    sendVerificationEmail: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            email: string;
-            callbackURL?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        email: string;
-        callbackURL?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    changeEmail: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            newEmail: string;
-            callbackURL?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        newEmail: string;
-        callbackURL?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    changePassword: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            newPassword: string;
-            currentPassword: string;
-            revokeOtherSessions?: boolean | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        newPassword: string;
-        currentPassword: string;
-        revokeOtherSessions?: boolean | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        token: string | null;
-        user: {
-            id: string;
-            email: string;
-            name: string;
-            image: string | null | undefined;
-            emailVerified: boolean;
-            createdAt: Date;
-            updatedAt: Date;
-        };
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    deleteUser: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            callbackURL?: string | undefined;
-            password?: string | undefined;
-            token?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<{
-        callbackURL?: string | undefined;
-        password?: string | undefined;
-        token?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        success: boolean;
-        message: string;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    resetPassword: {
-        ":token": <FetchOptions extends {
-            method?: string;
-            mode?: RequestMode;
-            priority?: RequestPriority;
-            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";
-            });
-            cache?: RequestCache;
-            credentials?: RequestCredentials;
-            integrity?: string;
-            keepalive?: boolean;
-            redirect?: RequestRedirect;
-            referrer?: string;
-            referrerPolicy?: ReferrerPolicy;
-            signal?: AbortSignal | null;
-            window?: null;
-            next?: NextFetchRequestConfig | undefined;
-            onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-            onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-            onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-            onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-            onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-            hookOptions?: {
-                cloneResponse?: boolean;
-            };
-            timeout?: number;
-            customFetchImpl?: import("better-auth/react").FetchEsque;
-            plugins?: import("better-auth/react").BetterFetchPlugin[];
-            baseURL?: string;
-            throw?: boolean;
-            auth?: {
-                type: "Bearer";
-                token: string | Promise<string> | (() => string | Promise<string>);
+                pathMatcher(path: string): path is "/email-otp/verify-email";
+                window: number;
+                max: number;
             } | {
-                type: "Basic";
-                username: string | (() => string);
-                password: string | (() => string);
+                pathMatcher(path: string): path is "/sign-in/email-otp";
+                window: number;
+                max: number;
             } | {
-                type: "Custom";
-                prefix: string | (() => string);
-                value: string | (() => string);
-            };
-            body?: undefined;
-            query?: Partial<{
-                callbackURL: string;
-            }> & Record<string, any>;
-            params?: {
-                token: string;
-            };
-            duplex?: "full" | "half";
-            jsonParser?: (text: string) => Promise<any> | any;
-            retry?: import("better-auth/react").RetryOptions;
-            retryAttempt?: number;
-            output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-            errorSchema?: import("better-auth/react").StandardSchemaV1;
-            disableValidation?: boolean;
-        }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<never, {
-            code?: string;
-            message?: string;
-        }, FetchOptions["throw"] extends true ? true : false>>;
-    };
-} & {
-    requestPasswordReset: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            email: string;
-            redirectTo?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        email: string;
-        redirectTo?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    resetPassword: {
-        ":token": <FetchOptions extends {
-            method?: string;
-            mode?: RequestMode;
-            priority?: RequestPriority;
-            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";
-            });
-            cache?: RequestCache;
-            credentials?: RequestCredentials;
-            integrity?: string;
-            keepalive?: boolean;
-            redirect?: RequestRedirect;
-            referrer?: string;
-            referrerPolicy?: ReferrerPolicy;
-            signal?: AbortSignal | null;
-            window?: null;
-            next?: NextFetchRequestConfig | undefined;
-            onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-            onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-            onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-            onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-            onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-            hookOptions?: {
-                cloneResponse?: boolean;
-            };
-            timeout?: number;
-            customFetchImpl?: import("better-auth/react").FetchEsque;
-            plugins?: import("better-auth/react").BetterFetchPlugin[];
-            baseURL?: string;
-            throw?: boolean;
-            auth?: {
-                type: "Bearer";
-                token: string | Promise<string> | (() => string | Promise<string>);
+                pathMatcher(path: string): path is "/email-otp/request-password-reset";
+                window: number;
+                max: number;
             } | {
-                type: "Basic";
-                username: string | (() => string);
-                password: string | (() => string);
+                pathMatcher(path: string): path is "/email-otp/reset-password";
+                window: number;
+                max: number;
             } | {
-                type: "Custom";
-                prefix: string | (() => string);
-                value: string | (() => string);
-            };
-            body?: undefined;
-            query?: Partial<{
-                callbackURL: string;
-            }> & Record<string, any>;
-            params?: {
-                token: string;
-            };
-            duplex?: "full" | "half";
-            jsonParser?: (text: string) => Promise<any> | any;
-            retry?: import("better-auth/react").RetryOptions;
-            retryAttempt?: number;
-            output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-            errorSchema?: import("better-auth/react").StandardSchemaV1;
-            disableValidation?: boolean;
-        }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<never, {
-            code?: string;
-            message?: string;
-        }, FetchOptions["throw"] extends true ? true : false>>;
-    };
-} & {
-    revokeSession: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            token: string;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        token: string;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    revokeSessions: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    revokeOtherSessions: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    linkSocial: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: 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;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").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;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        url: string;
-        redirect: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    listAccounts: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        id: string;
-        provider: string;
-        createdAt: Date;
-        updatedAt: Date;
-        accountId: string;
-        scopes: string[];
-    }[], {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    deleteUser: {
-        callback: <FetchOptions extends {
-            method?: string;
-            mode?: RequestMode;
-            priority?: RequestPriority;
-            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";
-            });
-            cache?: RequestCache;
-            credentials?: RequestCredentials;
-            integrity?: string;
-            keepalive?: boolean;
-            redirect?: RequestRedirect;
-            referrer?: string;
-            referrerPolicy?: ReferrerPolicy;
-            signal?: AbortSignal | null;
-            window?: null;
-            next?: NextFetchRequestConfig | undefined;
-            onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-            onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-            onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-            onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-            onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-            hookOptions?: {
-                cloneResponse?: boolean;
-            };
-            timeout?: number;
-            customFetchImpl?: import("better-auth/react").FetchEsque;
-            plugins?: import("better-auth/react").BetterFetchPlugin[];
-            baseURL?: string;
-            throw?: boolean;
-            auth?: {
-                type: "Bearer";
-                token: string | Promise<string> | (() => string | Promise<string>);
+                pathMatcher(path: string): path is "/forget-password/email-otp";
+                window: number;
+                max: number;
             } | {
-                type: "Basic";
-                username: string | (() => string);
-                password: string | (() => string);
+                pathMatcher(path: string): path is "/email-otp/request-email-change";
+                window: number;
+                max: number;
             } | {
-                type: "Custom";
-                prefix: string | (() => string);
-                value: string | (() => string);
+                pathMatcher(path: string): path is "/email-otp/change-email";
+                window: number;
+                max: number;
+            })[];
+            options: import("better-auth/plugins").EmailOTPOptions;
+            $ERROR_CODES: {
+                OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+                INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+                TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
             };
-            body?: undefined;
-            query?: Partial<{
-                token: string;
-                callbackURL?: string | undefined;
-            }> & Record<string, any>;
-            params?: Record<string, any>;
-            duplex?: "full" | "half";
-            jsonParser?: (text: string) => Promise<any> | any;
-            retry?: import("better-auth/react").RetryOptions;
-            retryAttempt?: number;
-            output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-            errorSchema?: import("better-auth/react").StandardSchemaV1;
-            disableValidation?: boolean;
-        }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-            success: boolean;
-            message: string;
-        }, {
-            code?: string;
-            message?: string;
-        }, FetchOptions["throw"] extends true ? true : false>>;
-    };
-} & {
-    unlinkAccount: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            providerId: string;
-            accountId?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        providerId: string;
-        accountId?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    refreshToken: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            providerId: string;
-            accountId?: string | undefined;
-            userId?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        providerId: string;
-        accountId?: string | undefined;
-        userId?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<import("better-auth").OAuth2Tokens, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    getAccessToken: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            providerId: string;
-            accountId?: string | undefined;
-            userId?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        providerId: string;
-        accountId?: string | undefined;
-        userId?: string | undefined;
-    } & {
-        fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        accessToken: string;
-        accessTokenExpiresAt: Date | undefined;
-        scopes: string[];
-        idToken: string | undefined;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    accountInfo: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            accountId: string;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        accountId: string;
-    } & {
+        }>;
+        atomListeners: {
+            matcher: (path: string) => path is "/email-otp/verify-email" | "/sign-in/email-otp" | "/email-otp/request-email-change";
+            signal: "$sessionSignal";
+        }[];
+        $ERROR_CODES: {
+            OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+            INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+            TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+        };
+    })[];
+}>;
+export declare const signIn: {
+    emailOtp: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        email: string;
+        otp: string;
+        name?: string;
+        image?: string;
+    } & Record<string, any>> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        email: string;
+        otp: string;
+        name?: string;
+        image?: string;
+    } & Record<string, any> & {
         fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<Omit<{
+        token: string;
         user: {
-            id: string | number;
-            name?: string;
-            email?: string | null;
-            image?: string;
-            emailVerified: boolean;
-        };
-        data: Record<string, any>;
-    }, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    signUp: {
-        email: <FetchOptions extends {
-            method?: string;
-            mode?: RequestMode;
-            priority?: RequestPriority;
-            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";
-            });
-            cache?: RequestCache;
-            credentials?: RequestCredentials;
-            integrity?: string;
-            keepalive?: boolean;
-            redirect?: RequestRedirect;
-            referrer?: string;
-            referrerPolicy?: ReferrerPolicy;
-            signal?: AbortSignal | null;
-            window?: null;
-            next?: NextFetchRequestConfig | undefined;
-            onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-            onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-            onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-            onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-            onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-            hookOptions?: {
-                cloneResponse?: boolean;
-            };
-            timeout?: number;
-            customFetchImpl?: import("better-auth/react").FetchEsque;
-            plugins?: import("better-auth/react").BetterFetchPlugin[];
-            baseURL?: string;
-            throw?: boolean;
-            auth?: {
-                type: "Bearer";
-                token: string | Promise<string> | (() => string | Promise<string>);
-            } | {
-                type: "Basic";
-                username: string | (() => string);
-                password: string | (() => string);
-            } | {
-                type: "Custom";
-                prefix: string | (() => string);
-                value: string | (() => string);
-            };
-            body?: Partial<{
-                name: string;
-                email: string;
-                password: string;
-                image?: string;
-                callbackURL?: string;
-                rememberMe?: boolean;
-            }> & Record<string, any>;
-            query?: Partial<Record<string, any>> & Record<string, any>;
-            params?: Record<string, any>;
-            duplex?: "full" | "half";
-            jsonParser?: (text: string) => Promise<any> | any;
-            retry?: import("better-auth/react").RetryOptions;
-            retryAttempt?: number;
-            output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-            errorSchema?: import("better-auth/react").StandardSchemaV1;
-            disableValidation?: boolean;
-        }>(data_0: import("better-auth").Prettify<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
             email: string;
+            emailVerified: boolean;
             name: string;
-            password: string;
-            image?: string;
-            callbackURL?: string;
-            fetchOptions?: FetchOptions;
-        } & {} & {}>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<{
-            token: null;
-            user: {
-                id: string;
-                email: string;
-                name: string;
-                image: string | null | undefined;
-                emailVerified: boolean;
-                createdAt: Date;
-                updatedAt: Date;
-            };
-        } | {
-            token: string;
-            user: {
-                id: string;
-                email: string;
-                name: string;
-                image: string | null | undefined;
-                emailVerified: boolean;
-                createdAt: Date;
-                updatedAt: Date;
-            };
-        }>, {
-            code?: string;
-            message?: string;
-        }, FetchOptions["throw"] extends true ? true : false>>;
-    };
-} & {
-    updateUser: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
+            image?: string | null | undefined;
         };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<Partial<{}> & {
-            name?: string;
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
             image?: string;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<{
-        image?: string | null;
-        name?: string;
-        fetchOptions?: FetchOptions;
-    } & Partial<{} & {}>>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
-        status: boolean;
+        } & {} & {}>;
     }, {
-        code?: string;
-        message?: string;
+        code?: string | undefined;
+        message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
 } & {
-    listSessions: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<import("better-auth").Prettify<{
-        id: string;
-        userId: string;
-        expiresAt: Date;
-        createdAt: Date;
-        updatedAt: Date;
-        token: string;
-        ipAddress?: string | null | undefined;
-        userAgent?: string | null | undefined;
-    }>[], {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    useSession: () => {
-        data: {
-            user: {
-                id: string;
-                emailVerified: boolean;
-                name: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email?: string;
-                image?: string;
-            };
-            session: {
-                id: string;
-                userId: string;
-                expiresAt: Date;
-                createdAt: Date;
-                updatedAt: Date;
-                token: string;
-                ipAddress?: string;
-                userAgent?: string;
-            };
-        };
-        isPending: boolean;
-        error: import("better-auth/react").BetterFetchError | null;
-        refetch: () => void;
-    };
-    $Infer: {
-        Session: {
-            user: {
-                id: string;
-                emailVerified: boolean;
-                name: string;
-                createdAt: Date;
-                updatedAt: Date;
+    social: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        provider: "google" | (string & {}) | "github" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "huggingface" | "slack" | "spotify" | "twitch" | "twitter" | "dropbox" | "kick" | "linear" | "linkedin" | "gitlab" | "tiktok" | "reddit" | "roblox" | "salesforce" | "vk" | "zoom" | "notion" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
+        callbackURL?: string;
+        newUserCallbackURL?: string;
+        errorCallbackURL?: string;
+        disableRedirect?: boolean;
+        idToken?: {
+            token: string;
+            nonce?: string;
+            accessToken?: string;
+            refreshToken?: string;
+            expiresAt?: number;
+            user?: {
+                name?: {
+                    firstName?: string;
+                    lastName?: string;
+                };
                 email?: string;
-                image?: string;
-            };
-            session: {
-                id: string;
-                userId: string;
-                expiresAt: Date;
-                createdAt: Date;
-                updatedAt: Date;
-                token: string;
-                ipAddress?: string;
-                userAgent?: string;
-            };
-        };
-    };
-    $fetch: import("better-auth/react").BetterFetch<{
-        plugins: (import("better-auth/react").BetterFetchPlugin | {
-            id: string;
-            name: string;
-            hooks: {
-                onSuccess: ((context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void) | undefined;
-                onError: ((context: import("better-auth/react").ErrorContext) => Promise<void> | void) | undefined;
-                onRequest: (<T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void) | undefined;
-                onResponse: ((context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void) | undefined;
             };
-        } | {
-            id: string;
-            name: string;
-            hooks: {
-                onSuccess(context: import("better-auth/react").SuccessContext<any>): void;
-            };
-        })[];
-        redirect?: RequestRedirect | undefined;
-        method: string;
-        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;
-        cache?: RequestCache | undefined;
-        credentials?: RequestCredentials;
-        integrity?: string | undefined;
-        keepalive?: boolean | undefined;
-        mode?: RequestMode | undefined;
-        priority?: RequestPriority | undefined;
-        referrer?: string | undefined;
-        referrerPolicy?: ReferrerPolicy | undefined;
-        signal?: (AbortSignal | null) | undefined;
-        window?: null | undefined;
-        onRetry?: ((response: import("better-auth/react").ResponseContext) => Promise<void> | void) | undefined;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        } | undefined;
-        timeout?: number | undefined;
-        customFetchImpl: import("better-auth/react").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-auth/react").RetryOptions | undefined;
-        retryAttempt?: number | undefined;
-        output?: (import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
-        errorSchema?: import("better-auth/react").StandardSchemaV1 | undefined;
-        disableValidation?: boolean | undefined;
-    }, unknown, unknown, {}>;
-    $store: {
-        notify: (signal?: Omit<string, "$sessionSignal"> | "$sessionSignal") => void;
-        listen: (signal: Omit<string, "$sessionSignal"> | "$sessionSignal", listener: (value: boolean, oldValue?: boolean | undefined) => void) => void;
-        atoms: Record<string, import("better-auth/react").WritableAtom<any>>;
-    };
-    $ERROR_CODES: {
-        USER_NOT_FOUND: string;
-        FAILED_TO_CREATE_USER: string;
-        FAILED_TO_CREATE_SESSION: string;
-        FAILED_TO_UPDATE_USER: string;
-        FAILED_TO_GET_SESSION: string;
-        INVALID_PASSWORD: string;
-        INVALID_EMAIL: string;
-        INVALID_EMAIL_OR_PASSWORD: string;
-        SOCIAL_ACCOUNT_ALREADY_LINKED: string;
-        PROVIDER_NOT_FOUND: string;
-        INVALID_TOKEN: string;
-        ID_TOKEN_NOT_SUPPORTED: string;
-        FAILED_TO_GET_USER_INFO: string;
-        USER_EMAIL_NOT_FOUND: string;
-        EMAIL_NOT_VERIFIED: string;
-        PASSWORD_TOO_SHORT: string;
-        PASSWORD_TOO_LONG: string;
-        USER_ALREADY_EXISTS: string;
-        EMAIL_CAN_NOT_BE_UPDATED: string;
-        CREDENTIAL_ACCOUNT_NOT_FOUND: string;
-        SESSION_EXPIRED: string;
-        FAILED_TO_UNLINK_LAST_ACCOUNT: string;
-        ACCOUNT_NOT_FOUND: string;
-        USER_ALREADY_HAS_PASSWORD: string;
-    };
-};
-export declare const signIn: {
-    social: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            provider: unknown;
-            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;
-            } | undefined;
-            scopes?: string[] | undefined;
-            requestSignUp?: boolean | undefined;
-            loginHint?: string | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        provider: unknown;
-        callbackURL?: string | undefined;
-        newUserCallbackURL?: string | undefined;
-        errorCallbackURL?: string | undefined;
-        disableRedirect?: boolean | undefined;
+        };
+        scopes?: string[];
+        requestSignUp?: boolean;
+        loginHint?: string;
+        additionalData?: Record<string, any>;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        provider: "google" | (string & {}) | "github" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "huggingface" | "slack" | "spotify" | "twitch" | "twitter" | "dropbox" | "kick" | "linear" | "linkedin" | "gitlab" | "tiktok" | "reddit" | "roblox" | "salesforce" | "vk" | "zoom" | "notion" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
+        callbackURL?: string;
+        newUserCallbackURL?: string;
+        errorCallbackURL?: string;
+        disableRedirect?: boolean;
         idToken?: {
             token: string;
-            nonce?: string | undefined;
-            accessToken?: string | undefined;
-            refreshToken?: string | undefined;
-            expiresAt?: number | undefined;
-        } | undefined;
-        scopes?: string[] | undefined;
-        requestSignUp?: boolean | undefined;
-        loginHint?: string | undefined;
+            nonce?: string;
+            accessToken?: string;
+            refreshToken?: string;
+            expiresAt?: number;
+            user?: {
+                name?: {
+                    firstName?: string;
+                    lastName?: string;
+                };
+                email?: string;
+            };
+        };
+        scopes?: string[];
+        requestSignUp?: boolean;
+        loginHint?: string;
+        additionalData?: Record<string, any>;
     } & {
         fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<{
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+        redirect: boolean;
+        url: string;
+    } | (Omit<{
         redirect: boolean;
         token: string;
         url: undefined;
         user: {
             id: string;
+            createdAt: Date;
+            updatedAt: Date;
             email: string;
-            name: string;
-            image: string | null | undefined;
             emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
             createdAt: Date;
             updatedAt: Date;
-        };
-    } | {
-        url: string;
-        redirect: boolean;
-    }>, {
-        code?: string;
-        message?: string;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+    }), {
+        code?: string | undefined;
+        message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
 } & {
-    email: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            email: string;
-            password: string;
-            callbackURL?: string | undefined;
-            rememberMe?: boolean | undefined;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
+    email: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        email: string;
+        password: string;
+        callbackURL?: string | undefined;
+        rememberMe?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
         email: string;
         password: string;
         callbackURL?: string | undefined;
         rememberMe?: boolean | undefined;
     } & {
         fetchOptions?: FetchOptions;
-    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<Omit<{
         redirect: boolean;
         token: string;
-        url: string | undefined;
+        url?: string | undefined;
         user: {
             id: string;
+            createdAt: Date;
+            updatedAt: Date;
             email: string;
-            name: string;
-            image: string | null | undefined;
             emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
             createdAt: Date;
             updatedAt: Date;
-        };
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
     }, {
-        code?: string;
-        message?: string;
+        code?: string | undefined;
+        message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
 }, signUp: {
-    email: <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: Partial<{
-            name: string;
-            email: string;
-            password: string;
-            image?: string;
-            callbackURL?: string;
-            rememberMe?: boolean;
-        }> & Record<string, any>;
-        query?: Partial<Record<string, any>> & Record<string, any>;
-        params?: Record<string, any>;
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0: import("better-auth").Prettify<{
-        email: string;
+    email: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
         name: string;
+        email: string;
         password: string;
-        image?: string;
-        callbackURL?: string;
-        fetchOptions?: FetchOptions;
-    } & {} & {}>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<{
+        image?: string | undefined;
+        callbackURL?: string | undefined;
+        rememberMe?: boolean | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<import("node_modules/better-auth/dist/client/path-to-object.mjs").InferSignUpEmailCtx<{
+        baseURL: string;
+        basePath: string;
+        plugins: ({
+            id: "additional-fields-client";
+            version: string;
+            $InferServerPlugin: {
+                id: "additional-fields";
+                version: string;
+                schema: {
+                    user: {
+                        fields: {};
+                    };
+                    session: {
+                        fields: {};
+                    };
+                };
+            };
+        } | {
+            id: "email-otp";
+            version: string;
+            $InferServerPlugin: ReturnType<(options: import("better-auth/plugins").EmailOTPOptions) => {
+                id: "email-otp";
+                version: string;
+                init(ctx: import("better-auth").AuthContext): {
+                    options: {
+                        emailVerification: {
+                            sendVerificationEmail(data: {
+                                user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    email?: string;
+                                    image?: string;
+                                };
+                                url: string;
+                                token: string;
+                            }, request: Request | undefined): Promise<void>;
+                        };
+                    };
+                } | undefined;
+                endpoints: {
+                    sendVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/send-verification-otp", {
+                        method: "POST";
+                        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>[];
+                        body: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            type: import("zod").ZodEnum<{
+                                "sign-in": "sign-in";
+                                "change-email": "change-email";
+                                "email-verification": "email-verification";
+                                "forget-password": "forget-password";
+                            }>;
+                        }, import("zod/v4/core").$strip>;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        success: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        success: boolean;
+                    }>;
+                    createVerificationOTP: import("better-auth").StrictEndpoint<string, {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            type: import("zod").ZodEnum<{
+                                "sign-in": "sign-in";
+                                "change-email": "change-email";
+                                "email-verification": "email-verification";
+                                "forget-password": "forget-password";
+                            }>;
+                        }, import("zod/v4/core").$strip>;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "string";
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, string>;
+                    getVerificationOTP: import("better-auth").StrictEndpoint<string, {
+                        method: "GET";
+                        query: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            type: import("zod").ZodEnum<{
+                                "sign-in": "sign-in";
+                                "change-email": "change-email";
+                                "email-verification": "email-verification";
+                                "forget-password": "forget-password";
+                            }>;
+                        }, import("zod/v4/core").$strip>;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    "200": {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        otp: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        otp: null;
+                    } | {
+                        otp: string;
+                    }>;
+                    checkVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/check-verification-otp", {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            type: import("zod").ZodEnum<{
+                                "sign-in": "sign-in";
+                                "change-email": "change-email";
+                                "email-verification": "email-verification";
+                                "forget-password": "forget-password";
+                            }>;
+                            otp: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        success: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        success: boolean;
+                    }>;
+                    verifyEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/verify-email", {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            otp: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                        metadata: {
+                            openapi: {
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        status: {
+                                                            type: string;
+                                                            description: string;
+                                                            enum: boolean[];
+                                                        };
+                                                        token: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        user: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        status: boolean;
+                        token: string;
+                        user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, any>;
+                    } | {
+                        status: boolean;
+                        token: null;
+                        user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, any>;
+                    }>;
+                    signInEmailOTP: import("better-auth").StrictEndpoint<"/sign-in/email-otp", {
+                        method: "POST";
+                        body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            otp: import("zod").ZodString;
+                            name: import("zod").ZodOptional<import("zod").ZodString>;
+                            image: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        token: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        user: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        token: string;
+                        user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    }>;
+                    requestPasswordResetEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-password-reset", {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        success: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        success: boolean;
+                    }>;
+                    forgetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/forget-password/email-otp", {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        success: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        success: boolean;
+                    }>;
+                    resetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/reset-password", {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            otp: import("zod").ZodString;
+                            password: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        success: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        success: boolean;
+                    }>;
+                    requestEmailChangeEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-email-change", {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            newEmail: import("zod").ZodString;
+                            otp: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                            session: {
+                                session: Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                };
+                                user: Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            };
+                        }>>[];
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        success: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        success: boolean;
+                    }>;
+                    changeEmailEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/change-email", {
+                        method: "POST";
+                        body: import("zod").ZodObject<{
+                            newEmail: import("zod").ZodString;
+                            otp: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>;
+                        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                            session: {
+                                session: Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                };
+                                user: Record<string, any> & {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            };
+                        }>>[];
+                        metadata: {
+                            openapi: {
+                                operationId: string;
+                                description: string;
+                                responses: {
+                                    200: {
+                                        description: string;
+                                        content: {
+                                            "application/json": {
+                                                schema: {
+                                                    type: "object";
+                                                    properties: {
+                                                        success: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    }, {
+                        success: boolean;
+                    }>;
+                };
+                hooks: {
+                    after: {
+                        matcher(context: import("better-auth").HookEndpointContext): boolean;
+                        handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+                    }[];
+                };
+                rateLimit: ({
+                    pathMatcher(path: string): path is "/email-otp/send-verification-otp";
+                    window: number;
+                    max: number;
+                } | {
+                    pathMatcher(path: string): path is "/email-otp/check-verification-otp";
+                    window: number;
+                    max: number;
+                } | {
+                    pathMatcher(path: string): path is "/email-otp/verify-email";
+                    window: number;
+                    max: number;
+                } | {
+                    pathMatcher(path: string): path is "/sign-in/email-otp";
+                    window: number;
+                    max: number;
+                } | {
+                    pathMatcher(path: string): path is "/email-otp/request-password-reset";
+                    window: number;
+                    max: number;
+                } | {
+                    pathMatcher(path: string): path is "/email-otp/reset-password";
+                    window: number;
+                    max: number;
+                } | {
+                    pathMatcher(path: string): path is "/forget-password/email-otp";
+                    window: number;
+                    max: number;
+                } | {
+                    pathMatcher(path: string): path is "/email-otp/request-email-change";
+                    window: number;
+                    max: number;
+                } | {
+                    pathMatcher(path: string): path is "/email-otp/change-email";
+                    window: number;
+                    max: number;
+                })[];
+                options: import("better-auth/plugins").EmailOTPOptions;
+                $ERROR_CODES: {
+                    OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+                    INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+                    TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+                };
+            }>;
+            atomListeners: {
+                matcher: (path: string) => path is "/email-otp/verify-email" | "/sign-in/email-otp" | "/email-otp/request-email-change";
+                signal: "$sessionSignal";
+            }[];
+            $ERROR_CODES: {
+                OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+                INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+                TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+            };
+        })[];
+    }, FetchOptions>>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<(Omit<{
         token: null;
         user: {
             id: string;
+            createdAt: Date;
+            updatedAt: Date;
             email: string;
-            name: string;
-            image: string | null | undefined;
             emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
             createdAt: Date;
             updatedAt: Date;
-        };
-    } | {
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+    }) | (Omit<{
         token: string;
         user: {
             id: string;
+            createdAt: Date;
+            updatedAt: Date;
             email: string;
-            name: string;
-            image: string | null | undefined;
             emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
             createdAt: Date;
             updatedAt: Date;
-        };
-    }>, {
-        code?: string;
-        message?: string;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+    }), {
+        code?: string | undefined;
+        message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
-}, signOut: <FetchOptions extends {
-    method?: string;
-    mode?: RequestMode;
-    priority?: RequestPriority;
-    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";
-    });
-    cache?: RequestCache;
-    credentials?: RequestCredentials;
-    integrity?: string;
-    keepalive?: boolean;
-    redirect?: RequestRedirect;
-    referrer?: string;
-    referrerPolicy?: ReferrerPolicy;
-    signal?: AbortSignal | null;
-    window?: null;
-    next?: NextFetchRequestConfig | undefined;
-    onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-    onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-    onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-    onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-    onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-    hookOptions?: {
-        cloneResponse?: boolean;
-    };
-    timeout?: number;
-    customFetchImpl?: import("better-auth/react").FetchEsque;
-    plugins?: import("better-auth/react").BetterFetchPlugin[];
-    baseURL?: string;
-    throw?: boolean;
-    auth?: {
-        type: "Bearer";
-        token: string | Promise<string> | (() => string | Promise<string>);
-    } | {
-        type: "Basic";
-        username: string | (() => string);
-        password: string | (() => string);
-    } | {
-        type: "Custom";
-        prefix: string | (() => string);
-        value: string | (() => string);
-    };
-    body?: undefined;
-    query?: Partial<Record<string, any>> & Record<string, any>;
-    params?: Record<string, any>;
-    duplex?: "full" | "half";
-    jsonParser?: (text: string) => Promise<any> | any;
-    retry?: import("better-auth/react").RetryOptions;
-    retryAttempt?: number;
-    output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-    errorSchema?: import("better-auth/react").StandardSchemaV1;
-    disableValidation?: boolean;
-}>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+}, signOut: <FetchOptions extends import("better-auth").ClientFetchOption<undefined, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
     success: boolean;
 }, {
-    code?: string;
-    message?: string;
+    code?: string | undefined;
+    message?: string | undefined;
 }, FetchOptions["throw"] extends true ? true : false>>, useSession: () => {
     data: {
-        user: {
+        user: import("better-auth").StripEmptyObjects<{
             id: string;
-            emailVerified: boolean;
-            name: string;
             createdAt: Date;
             updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
             email?: string;
             image?: string;
-        };
-        session: {
+        } & {} & {}>;
+        session: import("better-auth").StripEmptyObjects<{
             id: string;
-            userId: string;
-            expiresAt: Date;
             createdAt: Date;
             updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
             token: string;
             ipAddress?: string;
             userAgent?: string;
-        };
+        } & {} & {}>;
     };
     isPending: boolean;
+    isRefetching: boolean;
     error: import("better-auth/react").BetterFetchError | null;
-    refetch: () => void;
-}, forgetPassword: <FetchOptions extends {
-    method?: string;
-    mode?: RequestMode;
-    priority?: RequestPriority;
-    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";
-    });
-    cache?: RequestCache;
-    credentials?: RequestCredentials;
-    integrity?: string;
-    keepalive?: boolean;
-    redirect?: RequestRedirect;
-    referrer?: string;
-    referrerPolicy?: ReferrerPolicy;
-    signal?: AbortSignal | null;
-    window?: null;
-    next?: NextFetchRequestConfig | undefined;
-    onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-    onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-    onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-    onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-    onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-    hookOptions?: {
-        cloneResponse?: boolean;
-    };
-    timeout?: number;
-    customFetchImpl?: import("better-auth/react").FetchEsque;
-    plugins?: import("better-auth/react").BetterFetchPlugin[];
-    baseURL?: string;
-    throw?: boolean;
-    auth?: {
-        type: "Bearer";
-        token: string | Promise<string> | (() => string | Promise<string>);
-    } | {
-        type: "Basic";
-        username: string | (() => string);
-        password: string | (() => string);
-    } | {
-        type: "Custom";
-        prefix: string | (() => string);
-        value: string | (() => string);
-    };
-    body?: Partial<{
-        email: string;
-        redirectTo?: string | undefined;
-    }> & Record<string, any>;
-    query?: Partial<Record<string, any>> & Record<string, any>;
-    params?: Record<string, any>;
-    duplex?: "full" | "half";
-    jsonParser?: (text: string) => Promise<any> | any;
-    retry?: import("better-auth/react").RetryOptions;
-    retryAttempt?: number;
-    output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-    errorSchema?: import("better-auth/react").StandardSchemaV1;
-    disableValidation?: boolean;
-}>(data_0: import("better-auth").Prettify<{
+    refetch: (queryParams?: {
+        query?: import("better-auth").SessionQueryParams;
+    } | undefined) => Promise<void>;
+}, requestPasswordReset: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
     email: string;
-    redirectTo?: string | undefined;
+    redirectTo?: string;
+}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+    email: string;
+    redirectTo?: string;
 } & {
     fetchOptions?: FetchOptions;
 }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
     status: boolean;
+    message: string;
 }, {
-    code?: string;
-    message?: string;
-}, FetchOptions["throw"] extends true ? true : false>>, resetPassword: (<FetchOptions extends {
-    method?: string;
-    mode?: RequestMode;
-    priority?: RequestPriority;
-    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";
-    });
-    cache?: RequestCache;
-    credentials?: RequestCredentials;
-    integrity?: string;
-    keepalive?: boolean;
-    redirect?: RequestRedirect;
-    referrer?: string;
-    referrerPolicy?: ReferrerPolicy;
-    signal?: AbortSignal | null;
-    window?: null;
-    next?: NextFetchRequestConfig | undefined;
-    onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-    onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-    onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-    onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-    onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-    hookOptions?: {
-        cloneResponse?: boolean;
-    };
-    timeout?: number;
-    customFetchImpl?: import("better-auth/react").FetchEsque;
-    plugins?: import("better-auth/react").BetterFetchPlugin[];
-    baseURL?: string;
-    throw?: boolean;
-    auth?: {
-        type: "Bearer";
-        token: string | Promise<string> | (() => string | Promise<string>);
-    } | {
-        type: "Basic";
-        username: string | (() => string);
-        password: string | (() => string);
-    } | {
-        type: "Custom";
-        prefix: string | (() => string);
-        value: string | (() => string);
-    };
-    body?: Partial<{
-        newPassword: string;
-        token?: string | undefined;
-    }> & Record<string, any>;
-    query?: Partial<{
-        token?: string | undefined;
-    }> & Record<string, any>;
-    params?: Record<string, any>;
-    duplex?: "full" | "half";
-    jsonParser?: (text: string) => Promise<any> | any;
-    retry?: import("better-auth/react").RetryOptions;
-    retryAttempt?: number;
-    output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-    errorSchema?: import("better-auth/react").StandardSchemaV1;
-    disableValidation?: boolean;
-}>(data_0: import("better-auth").Prettify<{
+    code?: string | undefined;
+    message?: string | undefined;
+}, FetchOptions["throw"] extends true ? true : false>>, resetPassword: (<FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+    newPassword: string;
+    token?: string;
+}> & Record<string, any>, Partial<{
+    token?: string;
+}> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
     newPassword: string;
-    token?: string | undefined;
+    token?: string;
 } & {
     fetchOptions?: FetchOptions;
 }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
     status: boolean;
 }, {
-    code?: string;
-    message?: string;
+    code?: string | undefined;
+    message?: string | undefined;
 }, FetchOptions["throw"] extends true ? true : false>>) & {
-    ":token": <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<{
-            callbackURL: string;
-        }> & Record<string, any>;
-        params?: {
-            token: string;
-        };
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<never, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-} & {
-    ":token": <FetchOptions extends {
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        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";
-        });
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        integrity?: string;
-        keepalive?: boolean;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        next?: NextFetchRequestConfig | undefined;
-        onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-        onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-        onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-        onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-        onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-        hookOptions?: {
-            cloneResponse?: boolean;
-        };
-        timeout?: number;
-        customFetchImpl?: import("better-auth/react").FetchEsque;
-        plugins?: import("better-auth/react").BetterFetchPlugin[];
-        baseURL?: string;
-        throw?: boolean;
-        auth?: {
-            type: "Bearer";
-            token: string | Promise<string> | (() => string | Promise<string>);
-        } | {
-            type: "Basic";
-            username: string | (() => string);
-            password: string | (() => string);
-        } | {
-            type: "Custom";
-            prefix: string | (() => string);
-            value: string | (() => string);
-        };
-        body?: undefined;
-        query?: Partial<{
-            callbackURL: string;
-        }> & Record<string, any>;
-        params?: {
-            token: string;
-        };
-        duplex?: "full" | "half";
-        jsonParser?: (text: string) => Promise<any> | any;
-        retry?: import("better-auth/react").RetryOptions;
-        retryAttempt?: number;
-        output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-        errorSchema?: import("better-auth/react").StandardSchemaV1;
-        disableValidation?: boolean;
-    }>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<never, {
-        code?: string;
-        message?: string;
-    }, FetchOptions["throw"] extends true ? true : false>>;
-}, verifyEmail: <FetchOptions extends {
-    method?: string;
-    mode?: RequestMode;
-    priority?: RequestPriority;
-    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";
-    });
-    cache?: RequestCache;
-    credentials?: RequestCredentials;
-    integrity?: string;
-    keepalive?: boolean;
-    redirect?: RequestRedirect;
-    referrer?: string;
-    referrerPolicy?: ReferrerPolicy;
-    signal?: AbortSignal | null;
-    window?: null;
-    next?: NextFetchRequestConfig | undefined;
-    onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-    onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-    onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-    onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-    onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-    hookOptions?: {
-        cloneResponse?: boolean;
-    };
-    timeout?: number;
-    customFetchImpl?: import("better-auth/react").FetchEsque;
-    plugins?: import("better-auth/react").BetterFetchPlugin[];
-    baseURL?: string;
-    throw?: boolean;
-    auth?: {
-        type: "Bearer";
-        token: string | Promise<string> | (() => string | Promise<string>);
-    } | {
-        type: "Basic";
-        username: string | (() => string);
-        password: string | (() => string);
-    } | {
-        type: "Custom";
-        prefix: string | (() => string);
-        value: string | (() => string);
-    };
-    body?: undefined;
-    query?: Partial<{
+    ":token": <FetchOptions extends import("better-auth").ClientFetchOption<undefined, Partial<{
+        callbackURL: string;
+    }> & Record<string, any>, {
         token: string;
-        callbackURL?: string | undefined;
-    }> & Record<string, any>;
-    params?: Record<string, any>;
-    duplex?: "full" | "half";
-    jsonParser?: (text: string) => Promise<any> | any;
-    retry?: import("better-auth/react").RetryOptions;
-    retryAttempt?: number;
-    output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-    errorSchema?: import("better-auth/react").StandardSchemaV1;
-    disableValidation?: boolean;
-}>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<void | {
-    status: boolean;
-    user: {
-        id: any;
-        email: any;
-        name: any;
-        image: any;
-        emailVerified: any;
-        createdAt: any;
-        updatedAt: any;
-    };
-} | {
+    }>>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<never, {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+}, verifyEmail: <FetchOptions extends import("better-auth").ClientFetchOption<undefined, Partial<{
+    token: string;
+    callbackURL?: string;
+}> & Record<string, any>, Record<string, string>>>(data_0?: import("better-auth").Prettify<undefined>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<void | {
     status: boolean;
-    user: null;
 }>, {
-    code?: string;
-    message?: string;
-}, FetchOptions["throw"] extends true ? true : false>>, sendVerificationEmail: <FetchOptions extends {
-    method?: string;
-    mode?: RequestMode;
-    priority?: RequestPriority;
-    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";
-    });
-    cache?: RequestCache;
-    credentials?: RequestCredentials;
-    integrity?: string;
-    keepalive?: boolean;
-    redirect?: RequestRedirect;
-    referrer?: string;
-    referrerPolicy?: ReferrerPolicy;
-    signal?: AbortSignal | null;
-    window?: null;
-    next?: NextFetchRequestConfig | undefined;
-    onRequest?: <T extends Record<string, any>>(context: import("better-auth/react").RequestContext<T>) => Promise<import("better-auth/react").RequestContext | void> | import("better-auth/react").RequestContext | void;
-    onResponse?: (context: import("better-auth/react").ResponseContext) => Promise<Response | void | import("better-auth/react").ResponseContext> | Response | import("better-auth/react").ResponseContext | void;
-    onSuccess?: (context: import("better-auth/react").SuccessContext<any>) => Promise<void> | void;
-    onError?: (context: import("better-auth/react").ErrorContext) => Promise<void> | void;
-    onRetry?: (response: import("better-auth/react").ResponseContext) => Promise<void> | void;
-    hookOptions?: {
-        cloneResponse?: boolean;
-    };
-    timeout?: number;
-    customFetchImpl?: import("better-auth/react").FetchEsque;
-    plugins?: import("better-auth/react").BetterFetchPlugin[];
-    baseURL?: string;
-    throw?: boolean;
-    auth?: {
-        type: "Bearer";
-        token: string | Promise<string> | (() => string | Promise<string>);
-    } | {
-        type: "Basic";
-        username: string | (() => string);
-        password: string | (() => string);
-    } | {
-        type: "Custom";
-        prefix: string | (() => string);
-        value: string | (() => string);
-    };
-    body?: Partial<{
-        email: string;
-        callbackURL?: string | undefined;
-    }> & Record<string, any>;
-    query?: Partial<Record<string, any>> & Record<string, any>;
-    params?: Record<string, any>;
-    duplex?: "full" | "half";
-    jsonParser?: (text: string) => Promise<any> | any;
-    retry?: import("better-auth/react").RetryOptions;
-    retryAttempt?: number;
-    output?: import("better-auth/react").StandardSchemaV1 | typeof Blob | typeof File;
-    errorSchema?: import("better-auth/react").StandardSchemaV1;
-    disableValidation?: boolean;
-}>(data_0: import("better-auth").Prettify<{
+    code?: string | undefined;
+    message?: string | undefined;
+}, FetchOptions["throw"] extends true ? true : false>>, sendVerificationEmail: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
     email: string;
-    callbackURL?: string | undefined;
+    callbackURL?: string;
+}> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+    email: string;
+    callbackURL?: string;
 } & {
     fetchOptions?: FetchOptions;
 }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
     status: boolean;
 }, {
-    code?: string;
-    message?: string;
-}, FetchOptions["throw"] extends true ? true : false>>;
+    code?: string | undefined;
+    message?: string | undefined;
+}, FetchOptions["throw"] extends true ? true : false>>, emailOtp: {
+    sendVerificationOtp: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        email: string;
+        type: "sign-in" | "email-verification" | "forget-password" | "change-email";
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        email: string;
+        type: "sign-in" | "email-verification" | "forget-password" | "change-email";
+    } & {
+        fetchOptions?: FetchOptions;
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+        success: boolean;
+    }, {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+} & {
+    checkVerificationOtp: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        email: string;
+        type: "sign-in" | "email-verification" | "forget-password" | "change-email";
+        otp: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        email: string;
+        type: "sign-in" | "email-verification" | "forget-password" | "change-email";
+        otp: string;
+    } & {
+        fetchOptions?: FetchOptions;
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+        success: boolean;
+    }, {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+} & {
+    verifyEmail: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        email: string;
+        otp: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        email: string;
+        otp: string;
+    } & {
+        fetchOptions?: FetchOptions;
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<(Omit<{
+        status: boolean;
+        token: string;
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        } & Record<string, any>;
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+    }) | (Omit<{
+        status: boolean;
+        token: null;
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        } & Record<string, any>;
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+    }), {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+} & {
+    requestPasswordReset: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        email: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        email: string;
+    } & {
+        fetchOptions?: FetchOptions;
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+        success: boolean;
+    }, {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+} & {
+    resetPassword: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        email: string;
+        otp: string;
+        password: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        email: string;
+        otp: string;
+        password: string;
+    } & {
+        fetchOptions?: FetchOptions;
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+        success: boolean;
+    }, {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+} & {
+    requestEmailChange: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        newEmail: string;
+        otp?: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        newEmail: string;
+        otp?: string;
+    } & {
+        fetchOptions?: FetchOptions;
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+        success: boolean;
+    }, {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+} & {
+    changeEmail: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        newEmail: string;
+        otp: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string>>>(data_0: import("better-auth").Prettify<{
+        newEmail: string;
+        otp: string;
+    } & {
+        fetchOptions?: FetchOptions;
+    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
+        success: boolean;
+    }, {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
+};
+/**
+ * Force a REAL session-cookie refresh from the browser.
+ *
+ * Better Auth renews a session (rolling `updateAge`) whenever `getSession` is
+ * called — but the re-issued cookie only reaches the browser when the call runs
+ * in a context that can write cookies (Route Handler / Server Action). Session
+ * reads during Server Component render use `disableRefresh`, so an app that is
+ * only ever opened through server-rendered pages (typical for an installed PWA)
+ * would never get its cookie renewed.
+ *
+ * This helper hits Better Auth's own `GET /api/auth/get-session` endpoint —
+ * served by the `app/api/auth/[...all]` Route Handler, where `Set-Cookie`
+ * works — bypassing the cookie cache so the check reaches the database and the
+ * renewal is applied when due. Wire it with `useSessionCookieRefresh()` /
+ * `<SessionCookieRefresher />` (app open, tab visible again, back online).
+ */
+export declare function refreshSessionCookie(): Promise<{
+    data: {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+        session: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string;
+            userAgent?: string;
+        } & {} & {}>;
+    };
+    error: null;
+} | {
+    data: null;
+    error: {
+        code?: string | undefined;
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+    };
+}>;
 //# sourceMappingURL=auth-client.d.ts.map