better-auth 0.0.2-beta.7 → 0.0.2

package/dist/plugins.d.ts

@@ -1,55 +1,898 @@
-import { a as BetterAuthPlugin, P as Providers, B as BetterAuthOptions, C as Context, I as InternalResponse, G as GenericHandler } from './options-CH15FEBw.js';
-export { A as AfterHookHandler, b as BeforeHookHandler } from './options-CH15FEBw.js';
-import './types-DAxaMWCy.js';
-import 'zod';
+import { T as TwoFactorOptions, U as UserWithTwoFactor } from './client-A2Mt04KQ.js';
+export { O as OrganizationOptions, a as Passkey, P as PasskeyOptions, W as WebAuthnCookieType, g as getPasskeyActions, o as organization, b as passkey, p as passkeyClient, t as twoFactorClient } from './client-A2Mt04KQ.js';
+export { i as ac } from './index-Dg4eEXZW.js';
+import { G as GenericEndpointContext } from './index-W5nXvJ-p.js';
+import * as better_call from 'better-call';
+import { z } from 'zod';
+import 'nanostores';
+import './type-DbMyI3b5.js';
+import '@better-fetch/fetch';
+import './helper-B5_2Vzba.js';
+import '@nanostores/react';
+import '@vue/reactivity';
+import '@nanostores/vue';
+import '@nanostores/solid';
+import './schema-BOszzrbQ.js';
+import 'arctic';
+import './preact.js';
+import './statement-COylZd3J.js';
+import '@simplewebauthn/types';
+import 'kysely';
 
-interface EmailVerificationOptions {
-    /**
-     * Send email to the user with the verification url.
-     */
-    sendEmail: (email: string, url: string) => Promise<void>;
-    /**
-     * Expiry time for the token.
-     * @default 60 * 60 * 24 (1 day)
-     */
-    expiresIn?: number;
-    /**
-     * On which providers to enable email verification.
-     * @default ["credential"]
-     */
-    providers?: (keyof Providers)[];
-    /**
-     * Redirect URL after email verification.
-     */
-    redirectURL: {
-        /**
-         * URL to redirect to on success.
-         */
-        success: string;
-        /**
-         * URL to redirect to on error. The error will be =
-         * appended as a query param.
-         */
-        error: string;
+declare const twoFactor: <O extends TwoFactorOptions>(options: O) => {
+    id: "two-factor";
+    endpoints: {
+        enableTwoFactor: {
+            (ctx_0?: better_call.Context<"/two-factor/enable", {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            }> | undefined): Promise<{
+                status: boolean;
+            }>;
+            path: "/two-factor/enable";
+            options: {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        disableTwoFactor: {
+            (ctx_0?: better_call.Context<"/two-factor/disable", {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            }> | undefined): Promise<{
+                status: boolean;
+            }>;
+            path: "/two-factor/disable";
+            options: {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        verifyBackupCode: {
+            (ctx_0: better_call.Context<"/two-factor/verify-backup-code", {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    code: string;
+                }, {
+                    code: string;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    valid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
+                    };
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<{
+                status: boolean;
+            }>;
+            path: "/two-factor/verify-backup-code";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    code: string;
+                }, {
+                    code: string;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    valid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        generateBackupCodes: {
+            (ctx_0?: better_call.Context<"/two-factor/generate-backup-codes", {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            }> | undefined): Promise<{
+                status: boolean;
+                backupCodes: string[];
+            }>;
+            path: "/two-factor/generate-backup-codes";
+            options: {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        viewBackupCodes: {
+            (ctx_0?: better_call.Context<"/view/backup-codes", {
+                method: "GET";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            }> | undefined): Promise<{
+                status: boolean;
+                backupCodes: Promise<string[] | null>;
+            }>;
+            path: "/view/backup-codes";
+            options: {
+                method: "GET";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        send2FaOTP: {
+            (ctx_0?: better_call.Context<"/two-factor/send-otp", {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    valid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
+                    };
+                }>, better_call.EndpointOptions>[];
+            }> | undefined): Promise<{
+                status: boolean;
+            }>;
+            path: "/two-factor/send-otp";
+            options: {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    valid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        verifyOTP: {
+            (ctx_0: better_call.Context<"/two-factor/verify-otp", {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    code: string;
+                }, {
+                    code: string;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    valid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
+                    };
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<{
+                status: boolean;
+            }>;
+            path: "/two-factor/verify-otp";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    code: string;
+                }, {
+                    code: string;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    valid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        generateTOTP: {
+            (ctx_0?: better_call.Context<"/totp/generate", {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            }> | undefined): Promise<{
+                code: string;
+            }>;
+            path: "/totp/generate";
+            options: {
+                method: "POST";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        viewTOTPURI: {
+            (ctx_0?: better_call.Context<"/two-factor/get-totp-uri", {
+                method: "GET";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            }> | undefined): Promise<{
+                totpURI: string;
+            }>;
+            path: "/two-factor/get-totp-uri";
+            options: {
+                method: "GET";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        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;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        verifyTOTP: {
+            (ctx_0: better_call.Context<"/two-factor/verify-totp", {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    code: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    code: string;
+                    callbackURL?: string | undefined;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    valid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
+                    };
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<{
+                status: boolean;
+            }>;
+            path: "/two-factor/verify-totp";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    code: string;
+                    callbackURL?: string | undefined;
+                }, {
+                    code: string;
+                    callbackURL?: string | undefined;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    valid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
+                        };
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
     };
-}
+    options: O;
+    hooks: {
+        after: {
+            matcher(context: GenericEndpointContext): boolean;
+            handler: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                response: Response;
+            } | undefined>, better_call.EndpointOptions>;
+        }[];
+    };
+    schema: {
+        user: {
+            fields: {
+                twoFactorEnabled: {
+                    type: "boolean";
+                    required: false;
+                    defaultValue: false;
+                };
+                twoFactorSecret: {
+                    type: "string";
+                    required: false;
+                };
+                twoFactorBackupCodes: {
+                    type: "string";
+                    required: false;
+                    returned: false;
+                };
+            };
+        };
+    };
+};
+
+declare const username: () => {
+    id: "username";
+    endpoints: {
+        signInUsername: {
+            (ctx_0: better_call.Context<"/sign-in/username", {
+                method: "POST";
+                body: z.ZodObject<{
+                    username: z.ZodString;
+                    password: z.ZodString;
+                    dontRememberMe: z.ZodOptional<z.ZodBoolean>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    password: string;
+                    username: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }, {
+                    password: string;
+                    username: 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/username";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    username: z.ZodString;
+                    password: z.ZodString;
+                    dontRememberMe: z.ZodOptional<z.ZodBoolean>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    password: string;
+                    username: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }, {
+                    password: string;
+                    username: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        signUpUsername: {
+            (ctx_0: better_call.Context<"/sign-up/username", {
+                method: "POST";
+                body: z.ZodObject<{
+                    username: z.ZodString;
+                    name: z.ZodString;
+                    email: z.ZodString;
+                    password: z.ZodString;
+                    image: z.ZodOptional<z.ZodString>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    username: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    username: 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/username";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    username: z.ZodString;
+                    name: z.ZodString;
+                    email: z.ZodString;
+                    password: z.ZodString;
+                    image: z.ZodOptional<z.ZodString>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    username: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    username: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+    };
+    schema: {
+        user: {
+            fields: {
+                username: {
+                    type: "string";
+                    required: false;
+                    unique: true;
+                    returned: true;
+                };
+            };
+        };
+    };
+};
+
 /**
- * Email verification plugin. This plugin will send an email
- * to the user with a token to verify the email on sign up.
+ * Converts bearer token to session cookie
  */
-declare const emailVerification: (opts: EmailVerificationOptions) => BetterAuthPlugin;
-
-declare const getPlugins: (options: BetterAuthOptions) => BetterAuthPlugin[];
-declare const usePlugins: (context: Context, ignorePlugins?: string[]) => {
-    before: (context: Context) => Promise<{
-        context: Context;
-        response: InternalResponse | undefined;
-    }>;
-    after: (context: Context, fnResponse: InternalResponse) => Promise<{
-        context: Context;
-        response: InternalResponse | undefined;
-    }>;
+declare const bearer: () => {
+    id: "bearer";
+    hooks: {
+        before: {
+            matcher(context: GenericEndpointContext): boolean;
+            handler: (ctx: GenericEndpointContext) => Promise<void>;
+        }[];
+    };
 };
-declare const withPlugins: <T extends GenericHandler<any, any, any>>(fn: T, ignorePlugins?: string[]) => (ctx: Parameters<T>["0"]) => Promise<InternalResponse | ReturnType<T>>;
 
-export { BetterAuthPlugin, emailVerification, getPlugins, usePlugins, withPlugins };
+export { bearer, twoFactor, username };