vestrycms 0.0.0-stage → 0.1.0

package/dist/core/auth.d.ts

@@ -0,0 +1,1561 @@
+/**
+ * Sign-in and users, on Better Auth. Editors sign in with a one-time code
+ * emailed to them (the email OTP plugin); admins manage users through the
+ * admin plugin. Vestry adds: config-listed bootstrap admins, invitations,
+ * and a `lastLoginAt` field.
+ *
+ * Storage is whatever Better Auth accepts: a Cloudflare D1 binding in
+ * production, a `node:sqlite` database in development, the memory adapter
+ * in tests. Tables are created on first use with Better Auth's migrator.
+ */
+import { type BetterAuthOptions } from "better-auth";
+import type { Mailer } from "./mail.js";
+import { type PublicUser } from "./roles.js";
+export type AuthDatabase = NonNullable<BetterAuthOptions["database"]>;
+export interface VestryAuthOptions {
+    database: AuthDatabase;
+    mailer: Mailer;
+    /** Signs cookies and hashes codes. Required outside development. */
+    secret: string;
+    /** Origin the panel is served from, e.g. `https://example.org`. */
+    baseURL: string;
+    /** Path Better Auth's routes are mounted at, e.g. `/admin/api/auth`. */
+    basePath: string;
+    /** Cookie path, so the session cookie only travels with control-panel requests. */
+    cookiePath?: string;
+    /** Name of the site, used in emails. */
+    siteName: string;
+    /** Absolute URL of the control panel, used in invitation emails. */
+    adminUrl: string;
+    /** Addresses that are always admins (from the config). */
+    admins?: string[];
+    /** Development: no rate limiting, cookies without `Secure`. */
+    dev?: boolean;
+    /** Create or update the tables on first use (Kysely-backed databases only). */
+    migrate?: boolean;
+}
+export declare const SESSION_TTL_SECONDS: number;
+export declare const CODE_TTL_SECONDS: number;
+export declare function normalizeEmail(email: string): string;
+/** Display name fallback: the part before the `@`, title-cased a little. */
+export declare function nameFromEmail(email: string): string;
+export declare function createVestryAuth(opts: VestryAuthOptions): {
+    auth: import("better-auth").Auth<{
+        appName: string;
+        secret: string;
+        baseURL: string;
+        basePath: string;
+        database: any;
+        session: {
+            expiresIn: number;
+            updateAge: number;
+        };
+        rateLimit: {
+            enabled: boolean;
+            storage: "database";
+        };
+        advanced: {
+            cookiePrefix: string;
+            useSecureCookies: boolean;
+            defaultCookieAttributes: {
+                path: string;
+            };
+            ipAddress: {
+                ipAddressHeaders: string[];
+            };
+        };
+        user: {
+            additionalFields: {
+                lastLoginAt: {
+                    type: "date";
+                    required: false;
+                    input: false;
+                };
+            };
+        };
+        databaseHooks: {
+            session: {
+                create: {
+                    after: (session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    } & Record<string, unknown>, ctx: import("better-auth").GenericEndpointContext | null) => Promise<void>;
+                };
+            };
+        };
+        hooks: {
+            before: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+        };
+        plugins: [{
+            id: "email-otp";
+            version: string;
+            init(ctx: import("better-auth").AuthContext): {
+                options: {
+                    emailVerification: {
+                        sendVerificationEmail(data: {
+                            user: import("better-auth").User;
+                            url: string;
+                            token: string;
+                        }, request: Request | undefined): Promise<void>;
+                    };
+                };
+            } | undefined;
+            endpoints: {
+                sendVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/send-verification-otp", {
+                    method: "POST";
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>[];
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        type: import("zod").ZodEnum<{
+                            "sign-in": "sign-in";
+                            "change-email": "change-email";
+                            "email-verification": "email-verification";
+                            "forget-password": "forget-password";
+                        }>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                createVerificationOTP: import("better-auth").StrictEndpoint<string, {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        type: import("zod").ZodEnum<{
+                            "sign-in": "sign-in";
+                            "change-email": "change-email";
+                            "email-verification": "email-verification";
+                            "forget-password": "forget-password";
+                        }>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "string";
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, string>;
+                getVerificationOTP: import("better-auth").StrictEndpoint<string, {
+                    method: "GET";
+                    query: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        type: import("zod").ZodEnum<{
+                            "sign-in": "sign-in";
+                            "change-email": "change-email";
+                            "email-verification": "email-verification";
+                            "forget-password": "forget-password";
+                        }>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    otp: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    otp: null;
+                } | {
+                    otp: string;
+                }>;
+                checkVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/check-verification-otp", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        type: import("zod").ZodEnum<{
+                            "sign-in": "sign-in";
+                            "change-email": "change-email";
+                            "email-verification": "email-verification";
+                            "forget-password": "forget-password";
+                        }>;
+                        otp: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                verifyEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/verify-email", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        otp: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    status: {
+                                                        type: string;
+                                                        description: string;
+                                                        enum: boolean[];
+                                                    };
+                                                    token: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    status: boolean;
+                    token: string;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    } & Record<string, any>;
+                } | {
+                    status: boolean;
+                    token: null;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    } & Record<string, any>;
+                }>;
+                signInEmailOTP: import("better-auth").StrictEndpoint<"/sign-in/email-otp", {
+                    method: "POST";
+                    body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        otp: import("zod").ZodString;
+                        name: import("zod").ZodOptional<import("zod").ZodString>;
+                        image: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    token: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    token: string;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                }>;
+                requestPasswordResetEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-password-reset", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                forgetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/forget-password/email-otp", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                resetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/reset-password", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        otp: import("zod").ZodString;
+                        password: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                requestEmailChangeEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-email-change", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        newEmail: import("zod").ZodString;
+                        otp: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                changeEmailEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/change-email", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        newEmail: import("zod").ZodString;
+                        otp: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+            };
+            hooks: {
+                after: {
+                    matcher(context: import("better-auth").HookEndpointContext): boolean;
+                    handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+                }[];
+            };
+            rateLimit: ({
+                pathMatcher(path: string): path is "/email-otp/send-verification-otp";
+                window: number;
+                max: number;
+            } | {
+                pathMatcher(path: string): path is "/email-otp/check-verification-otp";
+                window: number;
+                max: number;
+            } | {
+                pathMatcher(path: string): path is "/email-otp/verify-email";
+                window: number;
+                max: number;
+            } | {
+                pathMatcher(path: string): path is "/sign-in/email-otp";
+                window: number;
+                max: number;
+            } | {
+                pathMatcher(path: string): path is "/email-otp/request-password-reset";
+                window: number;
+                max: number;
+            } | {
+                pathMatcher(path: string): path is "/email-otp/reset-password";
+                window: number;
+                max: number;
+            } | {
+                pathMatcher(path: string): path is "/forget-password/email-otp";
+                window: number;
+                max: number;
+            } | {
+                pathMatcher(path: string): path is "/email-otp/request-email-change";
+                window: number;
+                max: number;
+            } | {
+                pathMatcher(path: string): path is "/email-otp/change-email";
+                window: number;
+                max: number;
+            })[];
+            options: import("better-auth/plugins").EmailOTPOptions;
+            $ERROR_CODES: {
+                OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+                INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+                TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+            };
+        }, {
+            id: "admin";
+            version: string;
+            init(authContext: import("better-auth").AuthContext): {
+                options: {
+                    databaseHooks: {
+                        user: {
+                            create: {
+                                before(user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, unknown>): Promise<{
+                                    data: {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        email: string;
+                                        emailVerified: boolean;
+                                        name: string;
+                                        image?: string | null | undefined;
+                                        role: string;
+                                    };
+                                }>;
+                            };
+                        };
+                        session: {
+                            create: {
+                                before(session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, unknown>, ctx: import("better-auth").GenericEndpointContext | null): Promise<void>;
+                            };
+                        };
+                    };
+                };
+            };
+            hooks: {
+                after: {
+                    matcher(context: import("better-auth").HookEndpointContext): boolean;
+                    handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>>;
+                }[];
+            };
+            endpoints: {
+                setRole: import("better-auth").StrictEndpoint<"/admin/set-role", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        role: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
+                    }, import("zod/v4/core").$strip>;
+                    requireHeaders: true;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                userId: string;
+                                role: "admin" | "editor" | ("admin" | "editor")[];
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                getUser: import("better-auth").StrictEndpoint<"/admin/get-user", {
+                    method: "GET";
+                    query: import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import("better-auth/plugins").UserWithRole>;
+                createUser: import("better-auth").StrictEndpoint<"/admin/create-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        password: import("zod").ZodOptional<import("zod").ZodString>;
+                        name: import("zod").ZodString;
+                        role: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+                        data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                email: string;
+                                password?: string | undefined;
+                                name: string;
+                                role?: "admin" | "editor" | ("admin" | "editor")[] | undefined;
+                                data?: Record<string, any> | undefined;
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                adminUpdateUser: import("better-auth").StrictEndpoint<"/admin/update-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        data: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import("better-auth/plugins").UserWithRole>;
+                listUsers: import("better-auth").StrictEndpoint<"/admin/list-users", {
+                    method: "GET";
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    query: import("zod").ZodObject<{
+                        searchValue: import("zod").ZodOptional<import("zod").ZodString>;
+                        searchField: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            email: "email";
+                            name: "name";
+                        }>>;
+                        searchOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            contains: "contains";
+                            starts_with: "starts_with";
+                            ends_with: "ends_with";
+                        }>>;
+                        limit: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                        offset: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                        sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+                        sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>>;
+                        filterField: import("zod").ZodOptional<import("zod").ZodString>;
+                        filterValue: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, import("zod").ZodBoolean]>, import("zod").ZodArray<import("zod").ZodString>]>, import("zod").ZodArray<import("zod").ZodNumber>]>>;
+                        filterOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            in: "in";
+                            lte: "lte";
+                            eq: "eq";
+                            ne: "ne";
+                            lt: "lt";
+                            gt: "gt";
+                            gte: "gte";
+                            not_in: "not_in";
+                            contains: "contains";
+                            starts_with: "starts_with";
+                            ends_with: "ends_with";
+                        }>>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    users: {
+                                                        type: string;
+                                                        items: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                    total: {
+                                                        type: string;
+                                                    };
+                                                    limit: {
+                                                        type: string;
+                                                    };
+                                                    offset: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    users: import("better-auth/plugins").UserWithRole[];
+                    total: number;
+                }>;
+                listUserSessions: import("better-auth").StrictEndpoint<"/admin/list-user-sessions", {
+                    method: "POST";
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    sessions: {
+                                                        type: string;
+                                                        items: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
+                }>;
+                unbanUser: import("better-auth").StrictEndpoint<"/admin/unban-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                banUser: import("better-auth").StrictEndpoint<"/admin/ban-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        banReason: import("zod").ZodOptional<import("zod").ZodString>;
+                        banExpiresIn: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                impersonateUser: import("better-auth").StrictEndpoint<"/admin/impersonate-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    session: {
+                                                        $ref: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                stopImpersonating: import("better-auth").StrictEndpoint<"/admin/stop-impersonating", {
+                    method: "POST";
+                    requireHeaders: true;
+                }, {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    } & Record<string, any>;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    } & Record<string, any>;
+                }>;
+                revokeUserSession: import("better-auth").StrictEndpoint<"/admin/revoke-user-session", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        sessionToken: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                revokeUserSessions: import("better-auth").StrictEndpoint<"/admin/revoke-user-sessions", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                removeUser: import("better-auth").StrictEndpoint<"/admin/remove-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                setUserPassword: import("better-auth").StrictEndpoint<"/admin/set-user-password", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        newPassword: import("zod").ZodString;
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    status: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    status: boolean;
+                }>;
+                userHasPermission: import("better-auth").StrictEndpoint<"/admin/has-permission", {
+                    method: "POST";
+                    body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                        userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                        role: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodXor<readonly [import("zod").ZodObject<{
+                        permission: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        permissions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                    }, import("zod/v4/core").$strip>]>>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            requestBody: {
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                permissions: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    error: {
+                                                        type: string;
+                                                    };
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                permissions: {
+                                    readonly user?: ("create" | "list" | "set-role" | "ban" | "impersonate" | "impersonate-admins" | "delete" | "set-password" | "set-email" | "get" | "update")[] | undefined;
+                                    readonly session?: ("list" | "delete" | "revoke")[] | undefined;
+                                };
+                            } & {
+                                userId?: string | undefined;
+                                role?: "admin" | "editor" | undefined;
+                            };
+                        };
+                    };
+                }, {
+                    error: null;
+                    success: boolean;
+                }>;
+            };
+            $ERROR_CODES: {
+                USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: import("better-auth").RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+                FAILED_TO_CREATE_USER: import("better-auth").RawError<"FAILED_TO_CREATE_USER">;
+                USER_ALREADY_EXISTS: import("better-auth").RawError<"USER_ALREADY_EXISTS">;
+                YOU_CANNOT_BAN_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_BAN_YOURSELF">;
+                YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+                YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+                YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+                YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+                BANNED_USER: import("better-auth").RawError<"BANNED_USER">;
+                YOU_ARE_NOT_ALLOWED_TO_GET_USER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+                NO_DATA_TO_UPDATE: import("better-auth").RawError<"NO_DATA_TO_UPDATE">;
+                YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+                YOU_CANNOT_REMOVE_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+                YOU_CANNOT_IMPERSONATE_ADMINS: import("better-auth").RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+                INVALID_ROLE_TYPE: import("better-auth").RawError<"INVALID_ROLE_TYPE">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL">;
+                PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER: import("better-auth").RawError<"PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER">;
+                USER_ID_CANNOT_BE_UPDATED: import("better-auth").RawError<"USER_ID_CANNOT_BE_UPDATED">;
+            };
+            schema: {
+                user: {
+                    fields: {
+                        role: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        banned: {
+                            type: "boolean";
+                            defaultValue: false;
+                            required: false;
+                            input: false;
+                        };
+                        banReason: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        banExpires: {
+                            type: "date";
+                            required: false;
+                            input: false;
+                        };
+                    };
+                };
+                session: {
+                    fields: {
+                        impersonatedBy: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                    };
+                };
+            };
+            options: NoInfer<{
+                ac: {
+                    newRole<const TRoleStatements extends import("better-auth/plugins").Statements>(statements: import("better-auth/plugins").RoleInput<{
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }, TRoleStatements>): import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<TRoleStatements>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                    statements: {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    };
+                };
+                roles: {
+                    admin: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+                        readonly user: ["create", "list", "get", "update", "set-role", "delete"];
+                    }>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                    editor: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+                        readonly user: [];
+                    }>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                };
+                defaultRole: string;
+                adminRoles: string[];
+            }>;
+        }];
+    }>;
+    ensureMigrated: () => Promise<void>;
+    toPublicUser: (user: {
+        id: string;
+        email: string;
+        name: string;
+        role?: string | null;
+        emailVerified?: boolean;
+        createdAt: Date | string;
+        lastLoginAt?: Date | string | null;
+    }) => PublicUser;
+    isConfigAdmin: (email: string) => boolean;
+    sendInvite: (by: {
+        name: string;
+    }, user: PublicUser) => Promise<void>;
+};
+export type VestryAuth = ReturnType<typeof createVestryAuth>;