better-auth 0.0.2-beta.7 → 0.0.2

package/dist/index-W5nXvJ-p.d.ts

@@ -0,0 +1,1498 @@
+import * as better_call from 'better-call';
+import { Endpoint, EndpointResponse, ContextTools, CookieOptions, Context } from 'better-call';
+import * as zod from 'zod';
+import { ZodSchema } from 'zod';
+import { L as LiteralString, U as UnionToIntersection, P as Prettify } from './helper-B5_2Vzba.js';
+import { O as OAuthProvider, U as User, S as Session, A as Account } from './schema-BOszzrbQ.js';
+import { Migration, Kysely } from 'kysely';
+
+declare const createFieldAttribute: <T extends FieldType, C extends Omit<FieldAttributeConfig<T>, "type">>(type: T, config?: C) => {
+    required?: boolean;
+    returned?: boolean;
+    hashValue?: boolean;
+    defaultValue?: InferValueType<T> | (() => InferValueType<T>) | undefined;
+    transform?: ((value: InferValueType<T>) => InferValueType<T>) | undefined;
+    references?: {
+        /**
+         * The model to reference.
+         */
+        model: string;
+        /**
+         * The field on the referenced model.
+         */
+        field: string;
+        /**
+         * The action to perform when the reference is deleted.
+         * @default "cascade"
+         */
+        onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+    };
+    unique?: boolean;
+    validator?: ZodSchema;
+    type: T;
+};
+type FieldAttribute<T extends FieldType = FieldType> = {
+    type: T;
+} & FieldAttributeConfig<T>;
+type FieldType = "string" | "number" | "boolean" | "date";
+type InferValueType<T extends FieldType> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "date" ? Date : never;
+type InferFieldOutput<T extends FieldAttribute> = T["returned"] extends false ? never : T["required"] extends false ? InferValueType<T["type"]> | undefined : InferValueType<T["type"]>;
+type FieldAttributeConfig<T extends FieldType = FieldType> = {
+    /**
+     * if the field should be required on a new record.
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * If the value should be returned on a response body.
+     * @default true
+     */
+    returned?: boolean;
+    /**
+     * If the value should be hashed when it's stored.
+     * @default false
+     */
+    hashValue?: boolean;
+    /**
+     * Default value for the field
+     *
+     * Note: This will not create a default value on the database level. It will only
+     * be used when creating a new record.
+     */
+    defaultValue?: InferValueType<T> | (() => InferValueType<T>);
+    /**
+     * transform the value before storing it.
+     */
+    transform?: (value: InferValueType<T>) => InferValueType<T>;
+    /**
+     * Reference to another model.
+     */
+    references?: {
+        /**
+         * The model to reference.
+         */
+        model: string;
+        /**
+         * The field on the referenced model.
+         */
+        field: string;
+        /**
+         * The action to perform when the reference is deleted.
+         * @default "cascade"
+         */
+        onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+    };
+    unique?: boolean;
+    /**
+     * A zod schema to validate the value.
+     */
+    validator?: ZodSchema;
+};
+
+/**
+ * Adapter where clause
+ */
+type Where = {
+    operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte";
+    value: string;
+    field: string;
+    connector?: "AND" | "OR";
+};
+/**
+ * Adapter Interface
+ */
+interface Adapter {
+    create: <T, R = T>(data: {
+        model: string;
+        data: T;
+        select?: string[];
+    }) => Promise<R>;
+    findOne: <T>(data: {
+        model: string;
+        where: Where[];
+        select?: string[];
+    }) => Promise<T | null>;
+    findMany: <T>(data: {
+        model: string;
+        where?: Where[];
+    }) => Promise<T[]>;
+    update: <T>(data: {
+        model: string;
+        where: Where[];
+        update: Record<string, any>;
+    }) => Promise<T>;
+    delete: <T>(data: {
+        model: string;
+        where: Where[];
+    }) => Promise<void>;
+    /**
+     * adapter specific configuration
+     */
+    config?: {
+        /**
+         * the format of the date fields
+         */
+        dateFormat?: "number" | "date";
+        /**
+         * if the adapter will throw an error when a
+         * record already exists. If this is set to
+         * false, there will be a check if the record
+         * exists or not before creating a new one.
+         */
+        failsOnRecordExist?: boolean;
+    };
+    createSchema?: (data: {
+        model: string;
+        fields: Record<string, FieldAttribute>;
+    }[]) => Promise<void>;
+}
+
+type AuthEndpoint = Endpoint<(ctx: {
+    options: BetterAuthOptions;
+    body: any;
+    query: any;
+    headers: Headers;
+}) => Promise<EndpointResponse>>;
+
+type GenericEndpointContext = ContextTools & {
+    context: AuthContext;
+} & {
+    body: any;
+    request: Request;
+    headers: Headers;
+    params?: Record<string, string> | undefined;
+    query: any;
+    method: "*";
+};
+
+type PluginSchema = {
+    [table: string]: {
+        fields: {
+            [field in string]: FieldAttribute;
+        };
+        disableMigration?: boolean;
+    };
+};
+type BetterAuthPlugin = {
+    id: LiteralString;
+    endpoints?: {
+        [key: string]: AuthEndpoint;
+    };
+    middlewares?: {
+        path: string;
+        middleware: Endpoint;
+    }[];
+    hooks?: {
+        before?: {
+            matcher: (context: GenericEndpointContext) => boolean;
+            handler: (context: GenericEndpointContext) => Promise<void | {
+                context: Partial<GenericEndpointContext>;
+            }>;
+        }[];
+        after?: {
+            matcher: (context: GenericEndpointContext) => boolean;
+            handler: (context: GenericEndpointContext & {
+                returned: EndpointResponse;
+            }) => Promise<void | {
+                response: EndpointResponse;
+            }>;
+        }[];
+    };
+    /**
+     * Schema the plugin needs
+     *
+     * This will also be used to migrate the database. If the fields are dynamic from the plugins
+     * configuration each time the configuration is changed a new migration will be created.
+     *
+     * NOTE: If you want to create migrations manually using
+     * migrations option or any other way you
+     * can disable migration per table basis.
+     *
+     * @example
+     * ```ts
+     * schema: {
+     * 	user: {
+     * 		fields: {
+     * 			email: {
+     * 				 type: "string",
+     * 			},
+     * 			emailVerified: {
+     * 				type: "boolean",
+     * 				defaultValue: false,
+     * 			},
+     * 		},
+     * 	}
+     * } as PluginSchema
+     * ```
+     */
+    schema?: PluginSchema;
+    /**
+     * The migrations of the plugin. If you define schema that will automatically create
+     * migrations for you.
+     *
+     * ⚠️ Only uses this if you dont't want to use the schema option and you disabled migrations for
+     * the tables.
+     */
+    migrations?: Record<string, Migration>;
+    /**
+     * The options of the plugin
+     */
+    options?: Record<string, any>;
+};
+
+interface BetterAuthOptions {
+    /**
+     * Base URL for the better auth. This is typically the
+     * root URL where your
+     * application server is hosted. If not explicitly set,
+     * the system will check the following environment variable:
+     *
+     * process.env.BETTER_AUTH_URL
+     *
+     * If not set it will throw an error.
+     */
+    baseURL?: string;
+    /**
+     * Base path for the better auth. This is typically the path where the
+     * better auth routes are mounted.
+     *
+     * @default "/api/auth"
+     */
+    basePath?: string;
+    /**
+     * The secret to use for encryption,
+     * signing and hashing.
+     *
+     * By default better auth will look for
+     * the following environment variables:
+     * process.env.BETTER_AUTH_SECRET,
+     * process.env.AUTH_SECRET
+     * If none of these environment
+     * variables are set,
+     * it will default to
+     * "better-auth-secret-123456789".
+     *
+     * on production if it's not set
+     * it will throw an error.
+     *
+     * you can generate a good secret
+     * using the following command:
+     * @example
+     * ```bash
+     * openssl rand -base64 32
+     * ```
+     */
+    secret?: string;
+    /**
+     * list of social providers
+     */
+    socialProvider?: OAuthProvider[];
+    /**
+     * Plugins
+     */
+    plugins?: BetterAuthPlugin[];
+    /**
+     * Advanced options
+     */
+    advanced?: {
+        /**
+         * Use secure cookies
+         *
+         * @default false
+         */
+        useSecureCookies?: boolean;
+        /**
+         * Disable CSRF check
+         */
+        disableCSRFCheck?: boolean;
+    };
+    /**
+     * Disable logging
+     *
+     * @default false
+     */
+    disableLog?: boolean;
+    /**
+     * Database configuration
+     */
+    database: {
+        provider: "postgres" | "sqlite" | "mysql";
+        url: string;
+    } | Adapter;
+    /**
+     * User configuration
+     */
+    user?: {
+        /**
+         * The model name for the user. Defaults to "user".
+         */
+        modelName?: string;
+        /**
+         * Additional fields to add to the user model
+         */
+        additionalFields?: Record<string, FieldAttribute>;
+    };
+    session?: {
+        modelName?: string;
+        /**
+         * Expiration time for the session token. The value
+         * should be in seconds.
+         * @default 7 days (60 * 60 * 24 * 7)
+         */
+        expiresIn?: number;
+        /**
+         * How often the session should be refreshed. The value
+         * should be in seconds.
+         * If set 0 the session will be refreshed every time it is used.
+         * @default 1 day (60 * 60 * 24)
+         */
+        updateAge?: number;
+    };
+    account?: {
+        modelName?: string;
+    };
+    /**
+     * Email and password authentication
+     */
+    emailAndPassword?: {
+        /**
+         * Enable email and password authentication
+         *
+         * @default false
+         */
+        enabled: boolean;
+        /**
+         * The maximum length of the password.
+         *
+         * @default 8
+         */
+        maxPasswordLength?: number;
+        /**
+         * The minimum length of the password.
+         *
+         * @default 32
+         */
+        minPasswordLength?: number;
+        /**
+         * send reset password email
+         *
+         * @param token the token to send to the email. Make sure to include the token as a
+         * parameter in the URL. You'll need to send it back to reset the password.
+         * @param user the user to send the email to
+         */
+        sendResetPasswordToken?: (token: string, user: User) => Promise<void>;
+        /**
+         * @param email the email to send the verification email to
+         * @param url the url to send the verification email to
+         */
+        sendVerificationEmail?: (email: string, url: string) => Promise<void>;
+    };
+    /**
+     * List of trusted origins.
+     */
+    trustedOrigins?: string[];
+}
+
+type AdditionalSessionFields<Options extends BetterAuthOptions> = Options["plugins"] extends Array<infer T> ? T extends {
+    schema: {
+        session: {
+            fields: infer Field;
+        };
+    };
+} ? Field extends Record<string, FieldAttribute> ? {
+    [key in keyof Field]: InferFieldOutput<Field[key]>;
+} : {} : {} : {};
+type AdditionalUserFields<Options extends BetterAuthOptions> = Options["plugins"] extends Array<infer T> ? T extends {
+    schema: {
+        user: {
+            fields: infer Field;
+        };
+    };
+} ? Field extends Record<infer Key, FieldAttribute> ? Prettify<{
+    [key in Key as Field[key]["required"] extends false ? never : Field[key]["defaultValue"] extends boolean | string | number | Date | Function ? key : never]: InferFieldOutput<Field[key]>;
+} & {
+    [key in Key as Field[key]["returned"] extends false ? never : key]?: InferFieldOutput<Field[key]>;
+}> : {} : {} : {};
+type InferUser<O extends BetterAuthOptions | Auth> = UnionToIntersection<User & (O extends BetterAuthOptions ? AdditionalUserFields<O> : O extends Auth ? AdditionalUserFields<O["options"]> : {})>;
+type InferSession<O extends BetterAuthOptions | Auth> = UnionToIntersection<Session & (O extends BetterAuthOptions ? AdditionalSessionFields<O> : O extends Auth ? AdditionalSessionFields<O["options"]> : {})>;
+
+declare const createInternalAdapter: (adapter: Adapter, options: BetterAuthOptions) => {
+    createOAuthUser: (user: User, account: Account) => Promise<{
+        user: {
+            id: string;
+            name: string;
+            email: string;
+            emailVerified: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+            image?: string | undefined;
+        };
+        account: {
+            id: string;
+            userId: string;
+            accountId: string;
+            providerId: string;
+            password?: string | null | undefined;
+            accessToken?: string | null | undefined;
+            refreshToken?: string | null | undefined;
+            idToken?: string | null | undefined;
+            accessTokenExpiresAt?: Date | null | undefined;
+            refreshTokenExpiresAt?: Date | null | undefined;
+        };
+    } | null>;
+    createUser: (user: User) => Promise<{
+        id: string;
+        name: string;
+        email: string;
+        emailVerified: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        image?: string | undefined;
+    }>;
+    createSession: (userId: string, request?: Request) => Promise<{
+        id: string;
+        userId: string;
+        expiresAt: Date;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+    }>;
+    findSession: (sessionId: string) => Promise<{
+        session: {
+            id: string;
+            userId: string;
+            expiresAt: Date;
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+        };
+        user: {
+            id: string;
+            name: string;
+            email: string;
+            emailVerified: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+            image?: string | undefined;
+        };
+    } | null>;
+    updateSession: (session: Session) => Promise<{
+        id: string;
+        userId: string;
+        expiresAt: Date;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+    }>;
+    deleteSession: (id: string) => Promise<void>;
+    findUserByEmail: (email: string) => Promise<{
+        user: {
+            id: string;
+            name: string;
+            email: string;
+            emailVerified: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+            image?: string | undefined;
+        };
+        accounts: {
+            id: string;
+            userId: string;
+            accountId: string;
+            providerId: string;
+            password?: string | null | undefined;
+            accessToken?: string | null | undefined;
+            refreshToken?: string | null | undefined;
+            idToken?: string | null | undefined;
+            accessTokenExpiresAt?: Date | null | undefined;
+            refreshTokenExpiresAt?: Date | null | undefined;
+        }[];
+    } | null>;
+    findUserById: (userId: string) => Promise<{
+        id: string;
+        name: string;
+        email: string;
+        emailVerified: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        image?: string | undefined;
+    } | null>;
+    linkAccount: (account: Account) => Promise<{
+        id: string;
+        userId: string;
+        accountId: string;
+        providerId: string;
+        password?: string | null | undefined;
+        accessToken?: string | null | undefined;
+        refreshToken?: string | null | undefined;
+        idToken?: string | null | undefined;
+        accessTokenExpiresAt?: Date | null | undefined;
+        refreshTokenExpiresAt?: Date | null | undefined;
+    }>;
+    updateUserByEmail: (email: string, data: Partial<User & Record<string, any>>) => Promise<{
+        id: string;
+        name: string;
+        email: string;
+        emailVerified: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        image?: string | undefined;
+    }>;
+    updatePassword: (userId: string, password: string) => Promise<{
+        id: string;
+        userId: string;
+        accountId: string;
+        providerId: string;
+        password?: string | null | undefined;
+        accessToken?: string | null | undefined;
+        refreshToken?: string | null | undefined;
+        idToken?: string | null | undefined;
+        accessTokenExpiresAt?: Date | null | undefined;
+        refreshTokenExpiresAt?: Date | null | undefined;
+    }>;
+};
+type InternalAdapter = ReturnType<typeof createInternalAdapter>;
+
+declare const createKyselyAdapter: (config: BetterAuthOptions) => Kysely<any> | null;
+
+declare function getAdapter(options: BetterAuthOptions): Adapter;
+
+declare function getCookies(options: BetterAuthOptions): {
+    sessionToken: {
+        name: string;
+        options: {
+            httpOnly: true;
+            sameSite: "lax";
+            path: string;
+            secure: boolean;
+            maxAge: number;
+        };
+    };
+    csrfToken: {
+        name: string;
+        options: {
+            httpOnly: true;
+            sameSite: "lax";
+            path: string;
+            secure: boolean;
+            maxAge: number;
+        };
+    };
+    state: {
+        name: string;
+        options: {
+            httpOnly: true;
+            sameSite: "lax";
+            path: string;
+            secure: boolean;
+            maxAge: number;
+        };
+    };
+    pkCodeVerifier: {
+        name: string;
+        options: CookieOptions;
+    };
+    nonce: {
+        name: string;
+        options: CookieOptions;
+    };
+};
+declare function createCookieGetter(options: BetterAuthOptions): (cookieName: string, options?: CookieOptions) => {
+    name: string;
+    options: CookieOptions;
+};
+type BetterAuthCookies = ReturnType<typeof getCookies>;
+
+declare const createLogger: (options?: {
+    disabled?: boolean;
+}) => {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    box: (...args: any[]) => void;
+    success: (...args: any[]) => void;
+    break: (...args: any[]) => void;
+};
+
+type AuthContext = {
+    options: BetterAuthOptions;
+    baseURL: string;
+    authCookies: BetterAuthCookies;
+    logger: ReturnType<typeof createLogger>;
+    db: ReturnType<typeof createKyselyAdapter>;
+    adapter: ReturnType<typeof getAdapter>;
+    internalAdapter: ReturnType<typeof createInternalAdapter>;
+    createAuthCookie: ReturnType<typeof createCookieGetter>;
+    secret: string;
+};
+
+declare const router: <C extends AuthContext, Option extends BetterAuthOptions>(ctx: C) => {
+    handler: (request: Request) => Promise<Response>;
+    endpoints: {
+        signInOAuth: {
+            (ctx_0: Context<"/sign-in/social", {
+                method: "POST";
+                requireHeaders: true;
+                query: zod.ZodOptional<zod.ZodObject<{
+                    currentURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    currentURL?: string | undefined;
+                }, {
+                    currentURL?: string | undefined;
+                }>>;
+                body: zod.ZodObject<{
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                    provider: zod.ZodEnum<["github", ...("github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter")[]]>;
+                }, "strip", zod.ZodTypeAny, {
+                    provider: "github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter";
+                    callbackURL?: string | undefined;
+                }, {
+                    provider: "github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter";
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                url: string;
+                state: string;
+                codeVerifier: string;
+                redirect: boolean;
+            }>;
+            path: "/sign-in/social";
+            options: {
+                method: "POST";
+                requireHeaders: true;
+                query: zod.ZodOptional<zod.ZodObject<{
+                    currentURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    currentURL?: string | undefined;
+                }, {
+                    currentURL?: string | undefined;
+                }>>;
+                body: zod.ZodObject<{
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                    provider: zod.ZodEnum<["github", ...("github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter")[]]>;
+                }, "strip", zod.ZodTypeAny, {
+                    provider: "github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter";
+                    callbackURL?: string | undefined;
+                }, {
+                    provider: "github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter";
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        callbackOAuth: {
+            (ctx_0: Context<"/callback/:id", {
+                method: "GET";
+                query: zod.ZodObject<{
+                    state: zod.ZodString;
+                    code: zod.ZodString;
+                    code_verifier: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    code: string;
+                    state: string;
+                    code_verifier?: string | undefined;
+                }, {
+                    code: string;
+                    state: string;
+                    code_verifier?: string | undefined;
+                }>;
+                metadata: {
+                    onClient: "hide";
+                };
+            }>): Promise<never>;
+            path: "/callback/:id";
+            options: {
+                method: "GET";
+                query: zod.ZodObject<{
+                    state: zod.ZodString;
+                    code: zod.ZodString;
+                    code_verifier: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    code: string;
+                    state: string;
+                    code_verifier?: string | undefined;
+                }, {
+                    code: string;
+                    state: string;
+                    code_verifier?: string | undefined;
+                }>;
+                metadata: {
+                    onClient: "hide";
+                };
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        getCSRFToken: {
+            (ctx_0?: Context<"/csrf", {
+                method: "GET";
+                metadata: {
+                    onClient: "hide";
+                };
+            }> | undefined): Promise<{
+                csrfToken: string;
+            }>;
+            path: "/csrf";
+            options: {
+                method: "GET";
+                metadata: {
+                    onClient: "hide";
+                };
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        getSession: {
+            (ctx: Context<"/session", {
+                method: "GET";
+                requireHeaders: true;
+            }>): Promise<{
+                session: Prettify<InferSession<Option>>;
+                user: Prettify<InferUser<Option>>;
+            } | null>;
+            path: "/session";
+            method: better_call.Method | better_call.Method[];
+            options: {
+                method: "GET";
+                requireHeaders: true;
+            };
+            headers: Headers;
+        };
+        signOut: {
+            (ctx_0?: Context<"/sign-out", {
+                method: "POST";
+                body: zod.ZodOptional<zod.ZodObject<{
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    callbackURL?: string | undefined;
+                }, {
+                    callbackURL?: string | undefined;
+                }>>;
+            }> | undefined): Promise<null>;
+            path: "/sign-out";
+            options: {
+                method: "POST";
+                body: zod.ZodOptional<zod.ZodObject<{
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    callbackURL?: string | undefined;
+                }, {
+                    callbackURL?: string | undefined;
+                }>>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        signUpEmail: {
+            (ctx_0: Context<"/sign-up/email", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    name: zod.ZodString;
+                    email: zod.ZodString;
+                    password: zod.ZodString;
+                    image: zod.ZodOptional<zod.ZodString>;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                user: {
+                    id: string;
+                    name: string;
+                    email: string;
+                    emailVerified: boolean;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | undefined;
+                };
+                session: {
+                    id: string;
+                    userId: string;
+                    expiresAt: Date;
+                    ipAddress?: string | undefined;
+                    userAgent?: string | undefined;
+                };
+            } | null>;
+            path: "/sign-up/email";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    name: zod.ZodString;
+                    email: zod.ZodString;
+                    password: zod.ZodString;
+                    image: zod.ZodOptional<zod.ZodString>;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        signInEmail: {
+            (ctx_0: Context<"/sign-in/email", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                    password: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                    dontRememberMe: zod.ZodOptional<zod.ZodDefault<zod.ZodBoolean>>;
+                }, "strip", zod.ZodTypeAny, {
+                    password: string;
+                    email: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }, {
+                    password: string;
+                    email: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }>;
+            }>): Promise<{
+                user: {
+                    id: string;
+                    name: string;
+                    email: string;
+                    emailVerified: boolean;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | undefined;
+                };
+                session: {
+                    id: string;
+                    userId: string;
+                    expiresAt: Date;
+                    ipAddress?: string | undefined;
+                    userAgent?: string | undefined;
+                };
+                redirect: boolean;
+                url: string | undefined;
+            }>;
+            path: "/sign-in/email";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                    password: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                    dontRememberMe: zod.ZodOptional<zod.ZodDefault<zod.ZodBoolean>>;
+                }, "strip", zod.ZodTypeAny, {
+                    password: string;
+                    email: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }, {
+                    password: string;
+                    email: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        forgetPassword: {
+            (ctx_0: Context<"/forget-password", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                }, "strip", zod.ZodTypeAny, {
+                    email: string;
+                }, {
+                    email: string;
+                }>;
+            }>): Promise<{
+                error: string;
+            } | {
+                status: boolean;
+            } | null>;
+            path: "/forget-password";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                }, "strip", zod.ZodTypeAny, {
+                    email: string;
+                }, {
+                    email: string;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        resetPassword: {
+            (ctx_0: Context<"/reset-password", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    token: zod.ZodString;
+                    newPassword: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    token: string;
+                    newPassword: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    token: string;
+                    newPassword: string;
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                status: boolean;
+                url: string | undefined;
+                redirect: boolean;
+            } | null>;
+            path: "/reset-password";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    token: zod.ZodString;
+                    newPassword: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    token: string;
+                    newPassword: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    token: string;
+                    newPassword: string;
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        verifyEmail: {
+            (ctx_0: Context<"/verify-email", {
+                method: "GET";
+                query: zod.ZodObject<{
+                    token: zod.ZodString;
+                    callbackURL: zod.ZodString;
+                }, "strip", zod.ZodTypeAny, {
+                    token: string;
+                    callbackURL: string;
+                }, {
+                    token: string;
+                    callbackURL: string;
+                }>;
+            }>): Promise<{
+                status: boolean;
+            } | null>;
+            path: "/verify-email";
+            options: {
+                method: "GET";
+                query: zod.ZodObject<{
+                    token: zod.ZodString;
+                    callbackURL: zod.ZodString;
+                }, "strip", zod.ZodTypeAny, {
+                    token: string;
+                    callbackURL: string;
+                }, {
+                    token: string;
+                    callbackURL: string;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        sendVerificationEmail: {
+            (ctx_0: Context<"/send-verification-email", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    email: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    email: string;
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                status: boolean;
+            } | null>;
+            path: "/send-verification-email";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    email: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    email: string;
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+    };
+};
+
+declare const betterAuth: <O extends BetterAuthOptions>(options: O) => {
+    handler: (request: Request) => Promise<Response>;
+    api: {
+        signInOAuth: {
+            (ctx_0: better_call.Context<"/sign-in/social", {
+                method: "POST";
+                requireHeaders: true;
+                query: zod.ZodOptional<zod.ZodObject<{
+                    currentURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    currentURL?: string | undefined;
+                }, {
+                    currentURL?: string | undefined;
+                }>>;
+                body: zod.ZodObject<{
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                    provider: zod.ZodEnum<["github", ...("github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter")[]]>;
+                }, "strip", zod.ZodTypeAny, {
+                    provider: "github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter";
+                    callbackURL?: string | undefined;
+                }, {
+                    provider: "github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter";
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                url: string;
+                state: string;
+                codeVerifier: string;
+                redirect: boolean;
+            }>;
+            path: "/sign-in/social";
+            options: {
+                method: "POST";
+                requireHeaders: true;
+                query: zod.ZodOptional<zod.ZodObject<{
+                    currentURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    currentURL?: string | undefined;
+                }, {
+                    currentURL?: string | undefined;
+                }>>;
+                body: zod.ZodObject<{
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                    provider: zod.ZodEnum<["github", ...("github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter")[]]>;
+                }, "strip", zod.ZodTypeAny, {
+                    provider: "github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter";
+                    callbackURL?: string | undefined;
+                }, {
+                    provider: "github" | "apple" | "discord" | "facebook" | "google" | "spotify" | "twitch" | "twitter";
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        callbackOAuth: {
+            (ctx_0: better_call.Context<"/callback/:id", {
+                method: "GET";
+                query: zod.ZodObject<{
+                    state: zod.ZodString;
+                    code: zod.ZodString;
+                    code_verifier: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    code: string;
+                    state: string;
+                    code_verifier?: string | undefined;
+                }, {
+                    code: string;
+                    state: string;
+                    code_verifier?: string | undefined;
+                }>;
+                metadata: {
+                    onClient: "hide";
+                };
+            }>): Promise<never>;
+            path: "/callback/:id";
+            options: {
+                method: "GET";
+                query: zod.ZodObject<{
+                    state: zod.ZodString;
+                    code: zod.ZodString;
+                    code_verifier: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    code: string;
+                    state: string;
+                    code_verifier?: string | undefined;
+                }, {
+                    code: string;
+                    state: string;
+                    code_verifier?: string | undefined;
+                }>;
+                metadata: {
+                    onClient: "hide";
+                };
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        getCSRFToken: {
+            (ctx_0?: better_call.Context<"/csrf", {
+                method: "GET";
+                metadata: {
+                    onClient: "hide";
+                };
+            }> | undefined): Promise<{
+                csrfToken: string;
+            }>;
+            path: "/csrf";
+            options: {
+                method: "GET";
+                metadata: {
+                    onClient: "hide";
+                };
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        getSession: {
+            (ctx: better_call.Context<"/session", {
+                method: "GET";
+                requireHeaders: true;
+            }>): Promise<{
+                session: {
+                    id: string;
+                    userId: string;
+                    expiresAt: Date;
+                    ipAddress?: string | undefined;
+                    userAgent?: string | undefined;
+                };
+                user: {
+                    id: string;
+                    name: string;
+                    email: string;
+                    emailVerified: boolean;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | undefined;
+                };
+            } | null>;
+            path: "/session";
+            method: better_call.Method | better_call.Method[];
+            options: {
+                method: "GET";
+                requireHeaders: true;
+            };
+            headers: Headers;
+        };
+        signOut: {
+            (ctx_0?: better_call.Context<"/sign-out", {
+                method: "POST";
+                body: zod.ZodOptional<zod.ZodObject<{
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    callbackURL?: string | undefined;
+                }, {
+                    callbackURL?: string | undefined;
+                }>>;
+            }> | undefined): Promise<null>;
+            path: "/sign-out";
+            options: {
+                method: "POST";
+                body: zod.ZodOptional<zod.ZodObject<{
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    callbackURL?: string | undefined;
+                }, {
+                    callbackURL?: string | undefined;
+                }>>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        signUpEmail: {
+            (ctx_0: better_call.Context<"/sign-up/email", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    name: zod.ZodString;
+                    email: zod.ZodString;
+                    password: zod.ZodString;
+                    image: zod.ZodOptional<zod.ZodString>;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                user: {
+                    id: string;
+                    name: string;
+                    email: string;
+                    emailVerified: boolean;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | undefined;
+                };
+                session: {
+                    id: string;
+                    userId: string;
+                    expiresAt: Date;
+                    ipAddress?: string | undefined;
+                    userAgent?: string | undefined;
+                };
+            } | null>;
+            path: "/sign-up/email";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    name: zod.ZodString;
+                    email: zod.ZodString;
+                    password: zod.ZodString;
+                    image: zod.ZodOptional<zod.ZodString>;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        signInEmail: {
+            (ctx_0: better_call.Context<"/sign-in/email", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                    password: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                    dontRememberMe: zod.ZodOptional<zod.ZodDefault<zod.ZodBoolean>>;
+                }, "strip", zod.ZodTypeAny, {
+                    password: string;
+                    email: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }, {
+                    password: string;
+                    email: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }>;
+            }>): Promise<{
+                user: {
+                    id: string;
+                    name: string;
+                    email: string;
+                    emailVerified: boolean;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | undefined;
+                };
+                session: {
+                    id: string;
+                    userId: string;
+                    expiresAt: Date;
+                    ipAddress?: string | undefined;
+                    userAgent?: string | undefined;
+                };
+                redirect: boolean;
+                url: string | undefined;
+            }>;
+            path: "/sign-in/email";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                    password: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                    dontRememberMe: zod.ZodOptional<zod.ZodDefault<zod.ZodBoolean>>;
+                }, "strip", zod.ZodTypeAny, {
+                    password: string;
+                    email: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }, {
+                    password: string;
+                    email: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        forgetPassword: {
+            (ctx_0: better_call.Context<"/forget-password", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                }, "strip", zod.ZodTypeAny, {
+                    email: string;
+                }, {
+                    email: string;
+                }>;
+            }>): Promise<{
+                error: string;
+            } | {
+                status: boolean;
+            } | null>;
+            path: "/forget-password";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                }, "strip", zod.ZodTypeAny, {
+                    email: string;
+                }, {
+                    email: string;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        resetPassword: {
+            (ctx_0: better_call.Context<"/reset-password", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    token: zod.ZodString;
+                    newPassword: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    token: string;
+                    newPassword: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    token: string;
+                    newPassword: string;
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                status: boolean;
+                url: string | undefined;
+                redirect: boolean;
+            } | null>;
+            path: "/reset-password";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    token: zod.ZodString;
+                    newPassword: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    token: string;
+                    newPassword: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    token: string;
+                    newPassword: string;
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        verifyEmail: {
+            (ctx_0: better_call.Context<"/verify-email", {
+                method: "GET";
+                query: zod.ZodObject<{
+                    token: zod.ZodString;
+                    callbackURL: zod.ZodString;
+                }, "strip", zod.ZodTypeAny, {
+                    token: string;
+                    callbackURL: string;
+                }, {
+                    token: string;
+                    callbackURL: string;
+                }>;
+            }>): Promise<{
+                status: boolean;
+            } | null>;
+            path: "/verify-email";
+            options: {
+                method: "GET";
+                query: zod.ZodObject<{
+                    token: zod.ZodString;
+                    callbackURL: zod.ZodString;
+                }, "strip", zod.ZodTypeAny, {
+                    token: string;
+                    callbackURL: string;
+                }, {
+                    token: string;
+                    callbackURL: string;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        sendVerificationEmail: {
+            (ctx_0: better_call.Context<"/send-verification-email", {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    email: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    email: string;
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                status: boolean;
+            } | null>;
+            path: "/send-verification-email";
+            options: {
+                method: "POST";
+                body: zod.ZodObject<{
+                    email: zod.ZodString;
+                    callbackURL: zod.ZodOptional<zod.ZodString>;
+                }, "strip", zod.ZodTypeAny, {
+                    email: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    email: string;
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+    } & UnionToIntersection<O["plugins"] extends (infer T)[] ? T extends BetterAuthPlugin ? { [key in T["id"]]: T["endpoints"]; } : {} : {}>;
+    options: O;
+};
+type Auth = {
+    handler: (request: Request) => Promise<Response>;
+    api: ReturnType<typeof router>["endpoints"];
+    options: BetterAuthOptions;
+};
+
+export { type Auth as A, type BetterAuthPlugin as B, type FieldAttribute as F, type GenericEndpointContext as G, type InferFieldOutput as I, type BetterAuthOptions as a, type InferUser as b, type InferSession as c, betterAuth as d, createInternalAdapter as e, type InternalAdapter as f, createFieldAttribute as g, type FieldType as h, type InferValueType as i, type FieldAttributeConfig as j };