@celsoft/platform 0.4.0 → 0.6.0

package/dist/runtime/auth.d.ts

@@ -1,15 +1,1190 @@
-import { type BetterAuthOptions } from "better-auth";
-import { Pool } from "pg";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type { Email } from "./email.js";
 export declare const AUTH_PATH = "/api/auth";
+export declare const OWNER_ROLE = "owner";
 export interface AuthSettings {
-    pool: Pool;
+    db: NodePgDatabase<Record<string, unknown>>;
     secret: string;
     baseURL: string;
     email: Email;
     requireVerification: boolean;
 }
-export declare function authPool(connectionString: string): Pool;
-export declare function authOptions({ pool, secret, baseURL, email, requireVerification }: AuthSettings): BetterAuthOptions;
-export declare function createAuth(settings: AuthSettings): import("better-auth").Auth<BetterAuthOptions>;
+export declare function createAuth({ db, secret, baseURL, email, requireVerification }: AuthSettings): import("better-auth").Auth<{
+    secret: string;
+    baseURL: string;
+    basePath: string;
+    database: (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
+    advanced: {
+        database: {
+            generateId: "uuid";
+        };
+    };
+    rateLimit: {
+        enabled: false;
+    };
+    session: {
+        cookieCache: {
+            enabled: true;
+            maxAge: number;
+        };
+    };
+    emailAndPassword: {
+        enabled: true;
+        requireEmailVerification: boolean;
+        sendResetPassword: ({ user, url }: {
+            user: import("better-auth").User;
+            url: string;
+            token: string;
+        }) => Promise<void>;
+    };
+    emailVerification: {
+        sendOnSignUp: true;
+        autoSignInAfterVerification: true;
+        sendVerificationEmail: ({ user, url }: {
+            user: import("better-auth").User;
+            url: string;
+            token: string;
+        }) => Promise<void>;
+    };
+    databaseHooks: {
+        user: {
+            create: {
+                after: (user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, unknown>) => Promise<void>;
+            };
+        };
+    };
+    plugins: [{
+        id: "admin";
+        version: string;
+        init(): {
+            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("better-auth").ZodObject<{
+                    userId: import("better-auth").ZodCoercedString<unknown>;
+                    role: import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").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" | "owner" | "user" | ("admin" | "owner" | "user")[];
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            getUser: import("better-auth").StrictEndpoint<"/admin/get-user", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    id: import("better-auth").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("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                    password: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    name: import("better-auth").ZodString;
+                    role: import("better-auth").ZodOptional<import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>]>>;
+                    data: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").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" | "owner" | "user" | ("admin" | "owner" | "user")[] | undefined;
+                            data?: Record<string, any> | undefined;
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            adminUpdateUser: import("better-auth").StrictEndpoint<"/admin/update-user", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    userId: import("better-auth").ZodCoercedString<unknown>;
+                    data: import("better-auth").ZodRecord<import("better-auth").ZodAny, import("better-auth").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("better-auth").ZodObject<{
+                    searchValue: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    searchField: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        email: "email";
+                        name: "name";
+                    }>>;
+                    searchOperator: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        contains: "contains";
+                        starts_with: "starts_with";
+                        ends_with: "ends_with";
+                    }>>;
+                    limit: import("better-auth").ZodOptional<import("better-auth").ZodUnion<[import("better-auth").ZodString, import("better-auth").ZodNumber]>>;
+                    offset: import("better-auth").ZodOptional<import("better-auth").ZodUnion<[import("better-auth").ZodString, import("better-auth").ZodNumber]>>;
+                    sortBy: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    sortDirection: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                    filterField: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    filterValue: import("better-auth").ZodOptional<import("better-auth").ZodUnion<[import("better-auth").ZodUnion<[import("better-auth").ZodUnion<[import("better-auth").ZodUnion<[import("better-auth").ZodString, import("better-auth").ZodNumber]>, import("better-auth").ZodBoolean]>, import("better-auth").ZodArray<import("better-auth").ZodString>]>, import("better-auth").ZodArray<import("better-auth").ZodNumber>]>>;
+                    filterOperator: import("better-auth").ZodOptional<import("better-auth").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("better-auth").ZodObject<{
+                    userId: import("better-auth").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("better-auth").ZodObject<{
+                    userId: import("better-auth").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("better-auth").ZodObject<{
+                    userId: import("better-auth").ZodCoercedString<unknown>;
+                    banReason: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    banExpiresIn: import("better-auth").ZodOptional<import("better-auth").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("better-auth").ZodObject<{
+                    userId: import("better-auth").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("better-auth").ZodObject<{
+                    sessionToken: import("better-auth").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("better-auth").ZodObject<{
+                    userId: import("better-auth").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("better-auth").ZodObject<{
+                    userId: import("better-auth").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("better-auth").ZodObject<{
+                    newPassword: import("better-auth").ZodString;
+                    userId: import("better-auth").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("better-auth").ZodIntersection<import("better-auth").ZodObject<{
+                    userId: import("better-auth").ZodOptional<import("better-auth").ZodCoercedString<unknown>>;
+                    role: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>, import("better-auth").ZodXor<readonly [import("better-auth").ZodObject<{
+                    permission: import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                }, import("zod/v4/core").$strip>, import("better-auth").ZodObject<{
+                    permissions: import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").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?: ("ban" | "create" | "delete" | "get" | "impersonate" | "impersonate-admins" | "list" | "set-email" | "set-password" | "set-role" | "update")[] | undefined;
+                                readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                            };
+                        } & {
+                            userId?: string | undefined;
+                            role?: "admin" | "owner" | "user" | 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">;
+        };
+        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<{
+            defaultRole: string;
+            adminRoles: string[];
+            roles: {
+                owner: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+                    readonly user: ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "set-email", "get", "update"];
+                    readonly session: ["list", "revoke", "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"];
+                }>;
+                admin: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+                    readonly user: ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "set-email", "get", "update"];
+                    readonly session: ["list", "revoke", "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"];
+                }>;
+                user: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+                    readonly user: [];
+                    readonly session: [];
+                }>, {
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                    readonly session: readonly ["list", "revoke", "delete"];
+                }>;
+            };
+        }>;
+    }, {
+        id: "organization";
+        version: string;
+        endpoints: import("better-auth/plugins").OrganizationEndpoints<{
+            teams: {
+                enabled: true;
+            };
+            sendInvitationEmail: ({ email: to, organization: org, inviter, id }: {
+                id: string;
+                role: string;
+                email: string;
+                organization: import("better-auth/plugins").Organization;
+                invitation: import("better-auth/plugins").Invitation;
+                inviter: import("better-auth/plugins").Member & {
+                    user: import("better-auth").User;
+                };
+            }) => Promise<void>;
+        }> & import("better-auth/plugins").TeamEndpoints<{
+            teams: {
+                enabled: true;
+            };
+            sendInvitationEmail: ({ email: to, organization: org, inviter, id }: {
+                id: string;
+                role: string;
+                email: string;
+                organization: import("better-auth/plugins").Organization;
+                invitation: import("better-auth/plugins").Invitation;
+                inviter: import("better-auth/plugins").Member & {
+                    user: import("better-auth").User;
+                };
+            }) => Promise<void>;
+        }>;
+        schema: import("better-auth/plugins").OrganizationSchema<{
+            teams: {
+                enabled: true;
+            };
+            sendInvitationEmail: ({ email: to, organization: org, inviter, id }: {
+                id: string;
+                role: string;
+                email: string;
+                organization: import("better-auth/plugins").Organization;
+                invitation: import("better-auth/plugins").Invitation;
+                inviter: import("better-auth/plugins").Member & {
+                    user: import("better-auth").User;
+                };
+            }) => Promise<void>;
+        }>;
+        $Infer: {
+            Organization: {
+                id: string;
+                name: string;
+                slug: string;
+                logo?: string | null | undefined;
+                metadata?: any;
+                createdAt: Date;
+            };
+            Invitation: {
+                id: string;
+                organizationId: string;
+                email: string;
+                role: "admin" | "member" | "owner";
+                status: import("better-auth/plugins").InvitationStatus;
+                inviterId: string;
+                expiresAt: Date;
+                createdAt: Date;
+                teamId?: string | undefined;
+            };
+            Member: {
+                id: string;
+                organizationId: string;
+                role: "admin" | "member" | "owner";
+                createdAt: Date;
+                userId: string;
+                teamId?: string | undefined;
+                user: {
+                    id: string;
+                    email: string;
+                    name: string;
+                    image?: string | undefined;
+                };
+            };
+            Team: {
+                id: string;
+                name: string;
+                organizationId: string;
+                createdAt: Date;
+                updatedAt?: Date | undefined;
+            };
+            TeamMember: {
+                id: string;
+                teamId: string;
+                userId: string;
+                createdAt: Date;
+            };
+            ActiveOrganization: {
+                members: {
+                    id: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                    createdAt: Date;
+                    userId: string;
+                    teamId?: string | undefined;
+                    user: {
+                        id: string;
+                        email: string;
+                        name: string;
+                        image?: string | undefined;
+                    };
+                }[];
+                invitations: {
+                    id: string;
+                    organizationId: string;
+                    email: string;
+                    role: "admin" | "member" | "owner";
+                    status: import("better-auth/plugins").InvitationStatus;
+                    inviterId: string;
+                    expiresAt: Date;
+                    createdAt: Date;
+                    teamId?: string | undefined;
+                }[];
+                teams: {
+                    id: string;
+                    name: string;
+                    organizationId: string;
+                    createdAt: Date;
+                    updatedAt?: Date | undefined;
+                }[];
+            } & {
+                id: string;
+                name: string;
+                slug: string;
+                logo?: string | null | undefined;
+                metadata?: any;
+                createdAt: Date;
+            };
+        };
+        $ERROR_CODES: {
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION">;
+            YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS: import("better-auth").RawError<"YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS">;
+            ORGANIZATION_ALREADY_EXISTS: import("better-auth").RawError<"ORGANIZATION_ALREADY_EXISTS">;
+            ORGANIZATION_SLUG_ALREADY_TAKEN: import("better-auth").RawError<"ORGANIZATION_SLUG_ALREADY_TAKEN">;
+            ORGANIZATION_NOT_FOUND: import("better-auth").RawError<"ORGANIZATION_NOT_FOUND">;
+            USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION: import("better-auth").RawError<"USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION">;
+            NO_ACTIVE_ORGANIZATION: import("better-auth").RawError<"NO_ACTIVE_ORGANIZATION">;
+            USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION: import("better-auth").RawError<"USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION">;
+            MEMBER_NOT_FOUND: import("better-auth").RawError<"MEMBER_NOT_FOUND">;
+            ROLE_NOT_FOUND: import("better-auth").RawError<"ROLE_NOT_FOUND">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM">;
+            TEAM_ALREADY_EXISTS: import("better-auth").RawError<"TEAM_ALREADY_EXISTS">;
+            TEAM_NOT_FOUND: import("better-auth").RawError<"TEAM_NOT_FOUND">;
+            YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER: import("better-auth").RawError<"YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER">;
+            YOU_CANNOT_LEAVE_THE_ORGANIZATION_WITHOUT_AN_OWNER: import("better-auth").RawError<"YOU_CANNOT_LEAVE_THE_ORGANIZATION_WITHOUT_AN_OWNER">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER">;
+            YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION">;
+            USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION: import("better-auth").RawError<"USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION">;
+            INVITATION_NOT_FOUND: import("better-auth").RawError<"INVITATION_NOT_FOUND">;
+            YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION: import("better-auth").RawError<"YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION">;
+            EMAIL_VERIFICATION_REQUIRED_BEFORE_ACCEPTING_OR_REJECTING_INVITATION: import("better-auth").RawError<"EMAIL_VERIFICATION_REQUIRED_BEFORE_ACCEPTING_OR_REJECTING_INVITATION">;
+            EMAIL_VERIFICATION_REQUIRED_FOR_INVITATION: import("better-auth").RawError<"EMAIL_VERIFICATION_REQUIRED_FOR_INVITATION">;
+            YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION">;
+            INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION: import("better-auth").RawError<"INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE">;
+            FAILED_TO_RETRIEVE_INVITATION: import("better-auth").RawError<"FAILED_TO_RETRIEVE_INVITATION">;
+            YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS: import("better-auth").RawError<"YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS">;
+            UNABLE_TO_REMOVE_LAST_TEAM: import("better-auth").RawError<"UNABLE_TO_REMOVE_LAST_TEAM">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER">;
+            ORGANIZATION_MEMBERSHIP_LIMIT_REACHED: import("better-auth").RawError<"ORGANIZATION_MEMBERSHIP_LIMIT_REACHED">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM">;
+            INVITATION_LIMIT_REACHED: import("better-auth").RawError<"INVITATION_LIMIT_REACHED">;
+            TEAM_MEMBER_LIMIT_REACHED: import("better-auth").RawError<"TEAM_MEMBER_LIMIT_REACHED">;
+            USER_IS_NOT_A_MEMBER_OF_THE_TEAM: import("better-auth").RawError<"USER_IS_NOT_A_MEMBER_OF_THE_TEAM">;
+            YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM: import("better-auth").RawError<"YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM">;
+            YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM: import("better-auth").RawError<"YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER">;
+            YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER">;
+            YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION">;
+            YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION: import("better-auth").RawError<"YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION">;
+            MISSING_AC_INSTANCE: import("better-auth").RawError<"MISSING_AC_INSTANCE">;
+            YOU_MUST_BE_IN_AN_ORGANIZATION_TO_CREATE_A_ROLE: import("better-auth").RawError<"YOU_MUST_BE_IN_AN_ORGANIZATION_TO_CREATE_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_A_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_A_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_READ_A_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_READ_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_LIST_A_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_A_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_GET_A_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_A_ROLE">;
+            TOO_MANY_ROLES: import("better-auth").RawError<"TOO_MANY_ROLES">;
+            INVALID_RESOURCE: import("better-auth").RawError<"INVALID_RESOURCE">;
+            ROLE_NAME_IS_ALREADY_TAKEN: import("better-auth").RawError<"ROLE_NAME_IS_ALREADY_TAKEN">;
+            CANNOT_DELETE_A_PRE_DEFINED_ROLE: import("better-auth").RawError<"CANNOT_DELETE_A_PRE_DEFINED_ROLE">;
+            ROLE_IS_ASSIGNED_TO_MEMBERS: import("better-auth").RawError<"ROLE_IS_ASSIGNED_TO_MEMBERS">;
+            INVALID_TEAM_ID: import("better-auth").RawError<"INVALID_TEAM_ID">;
+        };
+        options: NoInfer<{
+            teams: {
+                enabled: true;
+            };
+            sendInvitationEmail: ({ email: to, organization: org, inviter, id }: {
+                id: string;
+                role: string;
+                email: string;
+                organization: import("better-auth/plugins").Organization;
+                invitation: import("better-auth/plugins").Invitation;
+                inviter: import("better-auth/plugins").Member & {
+                    user: import("better-auth").User;
+                };
+            }) => Promise<void>;
+        }>;
+    }];
+}>;
 export type Auth = ReturnType<typeof createAuth>;