export declare const authClient: {
    emailOtp: {
        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?: Partial<{
                email: string;
                otp: 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<{
            email: string;
            otp: string;
        } & {
            fetchOptions?: FetchOptions;
        }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<{
            status: boolean;
            token: string;
            user: {
                id: any;
                email: any;
                emailVerified: any;
                name: any;
                image: any;
                createdAt: any;
                updatedAt: any;
            };
        } | {
            status: boolean;
            token: null;
            user: {
                id: any;
                email: any;
                emailVerified: any;
                name: any;
                image: any;
                createdAt: any;
                updatedAt: any;
            };
        }>, {
            code?: string;
            message?: string;
        }, FetchOptions["throw"] extends true ? true : false>>;
    };
} & {
    signIn: {
        emailOtp: <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;
                otp: 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<{
            email: string;
            otp: string;
        } & {
            fetchOptions?: FetchOptions;
        }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
            token: string;
            user: {
                id: string;
                email: string;
                emailVerified: boolean;
                name: string;
                image: string | null | undefined;
                createdAt: Date;
                updatedAt: Date;
            };
        }, {
            code?: string;
            message?: string;
        }, FetchOptions["throw"] extends true ? true : false>>;
    };
} & {
    forgetPassword: {
        emailOtp: <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;
            }> & 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;
        } & {
            fetchOptions?: FetchOptions;
        }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
            success: boolean;
        }, {
            code?: string;
            message?: string;
        }, FetchOptions["throw"] extends true ? true : false>>;
    };
} & {
    emailOtp: {
        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<{
                email: string;
                otp: string;
                password: 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<{
            email: string;
            otp: string;
            password: string;
        } & {
            fetchOptions?: FetchOptions;
        }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
            success: boolean;
        }, {
            code?: string;
            message?: string;
        }, FetchOptions["throw"] extends true ? true : false>>;
    };
} & {
    emailOtp: {
        sendVerificationOtp: <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;
                type: "sign-in" | "forget-password" | "email-verification";
            }> & 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;
            type: "sign-in" | "forget-password" | "email-verification";
        } & {
            fetchOptions?: FetchOptions;
        }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
            success: boolean;
        }, {
            code?: string;
            message?: string;
        }, FetchOptions["throw"] extends true ? true : false>>;
    };
} & {
    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;
            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;
        } & {
            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;
            };
        } | {
            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;
            };
            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: 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>);
            } | {
                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>>;
    };
} & {
    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>);
            } | {
                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>>;
    };
} & {
    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>);
            } | {
                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<{
            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;
    } & {
        fetchOptions?: FetchOptions;
    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
        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<{
            email: string;
            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;
        };
        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;
            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;
    }, 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;
                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: {
    emailOtp: <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;
            otp: 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<{
        email: string;
        otp: string;
    } & {
        fetchOptions?: FetchOptions;
    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
        token: string;
        user: {
            id: string;
            email: string;
            emailVerified: boolean;
            name: string;
            image: string | null | undefined;
            createdAt: Date;
            updatedAt: Date;
        };
    }, {
        code?: string;
        message?: string;
    }, FetchOptions["throw"] extends true ? true : false>>;
} & {
    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;
        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;
    } & {
        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;
        };
    } | {
        url: string;
        redirect: boolean;
    }>, {
        code?: string;
        message?: string;
    }, 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: 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>>;
}, 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;
        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>>;
}, 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>>, 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;
}, 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: (<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>>) & {
    ":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: 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>>, emailOtp: {
    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?: Partial<{
            email: string;
            otp: 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<{
        email: string;
        otp: string;
    } & {
        fetchOptions?: FetchOptions;
    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<NonNullable<{
        status: boolean;
        token: string;
        user: {
            id: any;
            email: any;
            emailVerified: any;
            name: any;
            image: any;
            createdAt: any;
            updatedAt: any;
        };
    } | {
        status: boolean;
        token: null;
        user: {
            id: any;
            email: any;
            emailVerified: any;
            name: any;
            image: any;
            createdAt: any;
            updatedAt: any;
        };
    }>, {
        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<{
            email: string;
            otp: string;
            password: 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<{
        email: string;
        otp: string;
        password: string;
    } & {
        fetchOptions?: FetchOptions;
    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
        success: boolean;
    }, {
        code?: string;
        message?: string;
    }, FetchOptions["throw"] extends true ? true : false>>;
} & {
    sendVerificationOtp: <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;
            type: "sign-in" | "forget-password" | "email-verification";
        }> & 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;
        type: "sign-in" | "forget-password" | "email-verification";
    } & {
        fetchOptions?: FetchOptions;
    }>, data_1?: FetchOptions) => Promise<import("better-auth/react").BetterFetchResponse<{
        success: boolean;
    }, {
        code?: string;
        message?: string;
    }, FetchOptions["throw"] extends true ? true : false>>;
};
//# sourceMappingURL=auth-client.d.ts.map