@archlast/server 0.0.1

package/dist/auth/better-auth-instance.d.ts

@@ -0,0 +1,2464 @@
+/**
+ * Better-Auth Instance Configuration
+ *
+ * This file creates and exports the Better-Auth instance with all plugins configured.
+ * It includes:
+ * - Email and password authentication
+ * - Admin plugin (user management, roles, bans, impersonation)
+ * - Username plugin (username-based sign-in)
+ * - Anonymous plugin (guest users)
+ * - API Key plugin (API key management and authentication)
+ * - Organization plugin (multi-tenancy support)
+ */
+import type { IDatabaseClient } from "../db/interfaces.js";
+/**
+ * Better-Auth instance options
+ */
+export interface BetterAuthInstanceOptions {
+    /**
+     * Database client for the adapter
+     */
+    db: IDatabaseClient;
+    /**
+     * Require email verification in production
+     */
+    requireEmailVerification?: boolean;
+    /**
+     * Base URL for the application (for email links, redirects, etc.)
+     */
+    baseURL?: string;
+    /**
+     * Secret for signing tokens
+     */
+    secret?: string;
+    /**
+     * Allowed origins for API key requests
+     * Provide an array of allowed origin strings
+     * For development, include localhost and web app URLs
+     */
+    allowedOrigins?: string[];
+    /**
+     * Advanced options
+     */
+    advanced?: {
+        /**
+         * Use number IDs instead of string IDs
+         */
+        useNumberId?: boolean;
+        /**
+         * Custom ID generation function
+         */
+        generateId?: () => string;
+        /**
+         * Cookie prefix
+         */
+        cookiePrefix?: string;
+        /**
+         * Cross-subdomain cookies
+         */
+        crossSubDomainCookies?: {
+            enabled: boolean;
+            domain?: string;
+        };
+    };
+    /**
+     * Rate limiting
+     */
+    rateLimit?: {
+        /**
+         * Maximum requests per window
+         */
+        max: number;
+        /**
+         * Window in milliseconds
+         */
+        window: number;
+    };
+    /**
+     * Session configuration
+     */
+    session?: {
+        /**
+         * Session expiration time in milliseconds
+         */
+        expiresIn?: number;
+        /**
+         * Update session on every request
+         */
+        updateAge?: number;
+        /**
+         * Fresh session duration (for sensitive operations)
+         */
+        freshAge?: number;
+    };
+    /**
+     * Account configuration
+     */
+    account?: {
+        /**
+         * Allow multiple accounts per email
+         */
+        accountLinking?: {
+            enabled: boolean;
+            trustedProviders?: string[];
+        };
+        /**
+         * Account deletion options
+         */
+        accountDeletion?: {
+            enabled: boolean;
+            sendDeleteAccountConfirmation?: (email: string, code: string) => Promise<void>;
+        };
+    };
+    /**
+     * API Key configuration
+     */
+    apiKey?: {
+        /**
+         * Default prefix for API keys
+         */
+        defaultPrefix?: string;
+        /**
+         * Whether to require a name for API keys
+         */
+        requireName?: boolean;
+        /**
+         * Maximum name length for API keys
+         */
+        maximumNameLength?: number;
+        /**
+         * Enable metadata for API keys
+         */
+        enableMetadata?: boolean;
+        /**
+         * Default expiration time for API keys (in milliseconds)
+         */
+        defaultExpiresIn?: number | null;
+        /**
+         * Minimum expiration time (in days)
+         */
+        minExpiresIn?: number;
+        /**
+         * Maximum expiration time (in days)
+         */
+        maxExpiresIn?: number;
+        /**
+         * Rate limiting configuration for API keys
+         */
+        rateLimit?: {
+            enabled?: boolean;
+            timeWindow?: number;
+            maxRequests?: number;
+        };
+        /**
+         * Header name for API key
+         */
+        headerName?: string | string[];
+    };
+}
+/**
+ * Create a Better-Auth instance with Archlast adapter and plugins
+ */
+export declare function createBetterAuthInstance(userOptions: BetterAuthInstanceOptions): import("better-auth", { with: { "resolution-mode": "import" } }).Auth<{
+    database: any;
+    baseURL: string | undefined;
+    secret: string;
+    trustedOrigins: any;
+    emailAndPassword: {
+        enabled: true;
+        requireEmailVerification: boolean;
+        sendResetPassword: ({ user, url, token }: {
+            user: import("better-auth", { with: { "resolution-mode": "import" } }).User;
+            url: string;
+            token: string;
+        }) => Promise<void>;
+    };
+    advanced: {
+        generateId: (() => string) | undefined;
+        cookiePrefix: string;
+        crossSubDomainCookies: {
+            enabled: boolean;
+            domain?: string;
+        } | undefined;
+    };
+    session: {
+        expiresIn: number | undefined;
+        updateAge: number | undefined;
+        freshAge: number | undefined;
+        cookieCache: {
+            enabled: true;
+            maxAge: number;
+        };
+    };
+    rateLimit: {
+        window: number;
+        max: number;
+    } | undefined;
+    socialProviders: {};
+    plugins: [{
+        id: "admin";
+        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", { with: { "resolution-mode": "import" } }).GenericEndpointContext | null): Promise<void>;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            after: {
+                matcher(context: import("better-auth", { with: { "resolution-mode": "import" } }).HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<import("better-auth/plugins", { with: { "resolution-mode": "import" } }).SessionWithImpersonatedBy[] | undefined>;
+            }[];
+        };
+        endpoints: {
+            setRole: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/set-role", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                    role: import("better-auth", { with: { "resolution-mode": "import" } }).ZodUnion<readonly [import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodArray<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>]>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                requireHeaders: true;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                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: "user" | "admin" | ("user" | "admin")[];
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+            }>;
+            getUser: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/get-user", {
+                method: "GET";
+                query: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    id: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+            }>;
+            createUser: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/create-user", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    email: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                    password: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                    name: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                    role: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodUnion<readonly [import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodArray<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>]>>;
+                    data: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodRecord<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodAny>>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$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;
+                            name: string;
+                            role?: "user" | "admin" | ("user" | "admin")[] | undefined;
+                            data?: Record<string, any> | undefined;
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+            }>;
+            adminUpdateUser: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/update-user", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                    data: import("better-auth", { with: { "resolution-mode": "import" } }).ZodRecord<import("better-auth", { with: { "resolution-mode": "import" } }).ZodAny, import("better-auth", { with: { "resolution-mode": "import" } }).ZodAny>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                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", { with: { "resolution-mode": "import" } }).UserWithRole>;
+            listUsers: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/list-users", {
+                method: "GET";
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                query: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    searchValue: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                    searchField: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodEnum<{
+                        name: "name";
+                        email: "email";
+                    }>>;
+                    searchOperator: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodEnum<{
+                        contains: "contains";
+                        starts_with: "starts_with";
+                        ends_with: "ends_with";
+                    }>>;
+                    limit: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodUnion<[import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber]>>;
+                    offset: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodUnion<[import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber]>>;
+                    sortBy: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                    sortDirection: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                    filterField: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                    filterValue: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodUnion<[import("better-auth", { with: { "resolution-mode": "import" } }).ZodUnion<[import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber]>, import("better-auth", { with: { "resolution-mode": "import" } }).ZodBoolean]>>;
+                    filterOperator: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodEnum<{
+                        eq: "eq";
+                        ne: "ne";
+                        lt: "lt";
+                        lte: "lte";
+                        gt: "gt";
+                        gte: "gte";
+                        contains: "contains";
+                    }>>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$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", { with: { "resolution-mode": "import" } }).UserWithRole[];
+                total: number;
+                limit: number | undefined;
+                offset: number | undefined;
+            } | {
+                users: never[];
+                total: number;
+            }>;
+            listUserSessions: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/list-user-sessions", {
+                method: "POST";
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$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", { with: { "resolution-mode": "import" } }).SessionWithImpersonatedBy[];
+            }>;
+            unbanUser: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/unban-user", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, any>;
+            }>;
+            banUser: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/ban-user", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                    banReason: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                    banExpiresIn: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, any>;
+            }>;
+            impersonateUser: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/impersonate-user", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                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", { with: { "resolution-mode": "import" } }).UserWithRole;
+            }>;
+            stopImpersonating: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/stop-impersonating", {
+                method: "POST";
+                requireHeaders: true;
+            }, {
+                session: import("better-auth", { with: { "resolution-mode": "import" } }).Session & Record<string, any>;
+                user: import("better-auth", { with: { "resolution-mode": "import" } }).User & Record<string, any>;
+            }>;
+            revokeUserSession: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/revoke-user-session", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    sessionToken: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                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", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/revoke-user-sessions", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                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", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/remove-user", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                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", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/set-user-password", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    newPassword: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UserWithRole;
+                        session: import("better-auth", { with: { "resolution-mode": "import" } }).Session;
+                    };
+                }>)[];
+                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", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/admin/has-permission", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodIntersection<import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>>;
+                    role: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>, import("better-auth", { with: { "resolution-mode": "import" } }).ZodUnion<readonly [import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    permission: import("better-auth", { with: { "resolution-mode": "import" } }).ZodRecord<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodArray<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>>;
+                    permissions: import("better-auth", { with: { "resolution-mode": "import" } }).ZodUndefined;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>, import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    permission: import("better-auth", { with: { "resolution-mode": "import" } }).ZodUndefined;
+                    permissions: import("better-auth", { with: { "resolution-mode": "import" } }).ZodRecord<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodArray<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>]>>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        requestBody: {
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            permission: {
+                                                type: string;
+                                                description: string;
+                                                deprecated: boolean;
+                                            };
+                                            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: ({
+                            permission: {
+                                readonly user?: ("delete" | "list" | "set-role" | "create" | "update" | "get" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                            };
+                            permissions?: never | undefined;
+                        } | {
+                            permissions: {
+                                readonly user?: ("delete" | "list" | "set-role" | "create" | "update" | "get" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                            };
+                            permission?: never | undefined;
+                        }) & {
+                            userId?: string | undefined;
+                            role?: "user" | "admin" | undefined;
+                        };
+                    };
+                };
+            }, {
+                error: null;
+                success: boolean;
+            }>;
+        };
+        $ERROR_CODES: {
+            readonly FAILED_TO_CREATE_USER: "Failed to create user";
+            readonly USER_ALREADY_EXISTS: "User already exists.";
+            readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+            readonly YOU_CANNOT_BAN_YOURSELF: "You cannot ban yourself";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: "You are not allowed to change users role";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: "You are not allowed to create users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: "You are not allowed to list users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: "You are not allowed to list users sessions";
+            readonly YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: "You are not allowed to ban users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: "You are not allowed to impersonate users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: "You are not allowed to revoke users sessions";
+            readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: "You are not allowed to delete users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: "You are not allowed to set users password";
+            readonly BANNED_USER: "You have been banned from this application";
+            readonly YOU_ARE_NOT_ALLOWED_TO_GET_USER: "You are not allowed to get user";
+            readonly NO_DATA_TO_UPDATE: "No data to update";
+            readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: "You are not allowed to update users";
+            readonly YOU_CANNOT_REMOVE_YOURSELF: "You cannot remove yourself";
+            readonly YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: "You are not allowed to set a non-existent role value";
+            readonly YOU_CANNOT_IMPERSONATE_ADMINS: "You cannot impersonate admins";
+            readonly INVALID_ROLE_TYPE: "Invalid role type";
+        };
+        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;
+                    };
+                };
+            };
+        };
+        options: NoInfer<{
+            defaultRole: string;
+            adminRoles: string[];
+            deleteUserAccount: {
+                enabled: boolean;
+                sendDeleteAccountConfirmation: () => Promise<void>;
+            };
+        }>;
+    }, {
+        id: "username";
+        init(ctx: import("better-auth", { with: { "resolution-mode": "import" } }).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>, context: import("better-auth", { with: { "resolution-mode": "import" } }).GenericEndpointContext | null): Promise<{
+                                data: {
+                                    displayUsername?: string | undefined;
+                                    username?: string | undefined;
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                        };
+                        update: {
+                            before(user: Partial<{
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            }> & Record<string, unknown>, context: import("better-auth", { with: { "resolution-mode": "import" } }).GenericEndpointContext | null): Promise<{
+                                data: {
+                                    displayUsername?: string | undefined;
+                                    username?: string | undefined;
+                                    id? /**
+                                     * Maximum expiration time (in days)
+                                     */: string | undefined;
+                                    createdAt?: Date | undefined;
+                                    updatedAt
+                                    /**
+                                     * Rate limiting configuration for API keys
+                                     */
+                                    ? /**
+                                     * Rate limiting configuration for API keys
+                                     */: Date | undefined;
+                                    email?: string | undefined;
+                                    emailVerified?: boolean | undefined;
+                                    name?: string | undefined;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                        };
+                    };
+                };
+            };
+        };
+        endpoints: {
+            signInUsername: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/sign-in/username", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    username: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                    password: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                    rememberMe: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodBoolean>;
+                    callbackURL: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            422: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                message: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: {
+                    id: string;
+                    email: string;
+                    emailVerified: boolean;
+                    username: string;
+                    displayUsername: string;
+                    name: string;
+                    image: string | null | undefined;
+                    createdAt: Date;
+                    updatedAt: Date;
+                };
+            } | null>;
+            isUsernameAvailable: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/is-username-available", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    username: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+            }, {
+                available: boolean;
+            }>;
+        };
+        schema: {
+            user: {
+                fields: {
+                    username: {
+                        type: "string";
+                        required: false;
+                        sortable: true;
+                        unique: true;
+                        returned: true;
+                        transform: {
+                            input(value: import("better-auth", { with: { "resolution-mode": "import" } }).DBPrimitive): string | number | boolean | Date | unknown[] | Record<string, unknown> | null | undefined;
+                        };
+                    };
+                    displayUsername: {
+                        type: "string";
+                        required: false;
+                        transform: {
+                            input(value: import("better-auth", { with: { "resolution-mode": "import" } }).DBPrimitive): string | number | boolean | Date | unknown[] | Record<string, unknown> | null | undefined;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            before: {
+                matcher(context: import("better-auth", { with: { "resolution-mode": "import" } }).HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        options: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).UsernameOptions | undefined;
+        $ERROR_CODES: {
+            readonly INVALID_USERNAME_OR_PASSWORD: "Invalid username or password";
+            readonly EMAIL_NOT_VERIFIED: "Email not verified";
+            readonly UNEXPECTED_ERROR: "Unexpected error";
+            readonly USERNAME_IS_ALREADY_TAKEN: "Username is already taken. Please try another.";
+            readonly USERNAME_TOO_SHORT: "Username is too short";
+            readonly USERNAME_TOO_LONG: "Username is too long";
+            readonly INVALID_USERNAME: "Username is invalid";
+            readonly INVALID_DISPLAY_USERNAME: "Display username is invalid";
+        };
+    }, {
+        id: "anonymous";
+        endpoints: {
+            signInAnonymous: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/sign-in/anonymous", {
+                method: "POST";
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: {
+                    id: string;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                };
+            } | null>;
+        };
+        hooks: {
+            after: {
+                matcher(ctx: import("better-auth", { with: { "resolution-mode": "import" } }).HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        options: import("../../node_modules/better-auth/dist/plugins/anonymous/types.mjs", { with: { "resolution-mode": "import" } }).AnonymousOptions | undefined;
+        schema: {
+            user: {
+                fields: {
+                    isAnonymous: {
+                        type: "boolean";
+                        required: false;
+                        input: false;
+                        defaultValue: false;
+                    };
+                };
+            };
+        };
+        $ERROR_CODES: {
+            readonly INVALID_EMAIL_FORMAT: "Email was not generated in a valid format";
+            readonly FAILED_TO_CREATE_USER: "Failed to create user";
+            readonly COULD_NOT_CREATE_SESSION: "Could not create session";
+            readonly ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY: "Anonymous users cannot sign in again anonymously";
+        };
+    }, {
+        id: "organization";
+        endpoints: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).OrganizationEndpoints<{
+            allowUserToCreateOrganization: true;
+            creatorRole: string;
+            membershipLimit: number;
+        }>;
+        schema: {
+            organization: {
+                modelName: string;
+                fields: {
+                    name: {
+                        type: "string";
+                        required: true;
+                        sortable: true;
+                    };
+                    slug: {
+                        type: "string";
+                        required: true;
+                        unique: true;
+                        sortable: true;
+                    };
+                    logo: {
+                        type: "string";
+                        required: false;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                    };
+                    updatedAt: {
+                        type: "date";
+                        required: false;
+                    };
+                };
+            };
+            member: {
+                modelName: string;
+                fields: {
+                    organizationId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: "organization";
+                            field: "id";
+                        };
+                    };
+                    userId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: "user";
+                            field: "id";
+                        };
+                    };
+                    role: {
+                        type: "string";
+                        required: true;
+                        defaultValue: "member";
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                    };
+                };
+            };
+            invitation: {
+                modelName: string;
+                fields: {
+                    organizationId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: "organization";
+                            field: "id";
+                        };
+                    };
+                    email: {
+                        type: "string";
+                        required: true;
+                        sortable: true;
+                    };
+                    role: {
+                        type: "string";
+                        required: true;
+                        sortable: true;
+                    };
+                    status: {
+                        type: "string";
+                        required: true;
+                        sortable: true;
+                        defaultValue: "pending";
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                        defaultValue: Date;
+                    };
+                    inviterId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: "user";
+                            field: "id";
+                        };
+                    };
+                };
+            };
+            session: {
+                fields: {
+                    activeOrganizationId: {
+                        type: "string";
+                        required: false;
+                    };
+                };
+            };
+        };
+        $Infer: {
+            Organization: {
+                id: string;
+                name: string;
+                slug: string;
+                createdAt: Date;
+                logo?: string | null | undefined;
+                metadata?: any;
+            };
+            Invitation: {
+                id: string;
+                organizationId: string;
+                email: string;
+                role: "admin" | "owner" | "member";
+                status: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).InvitationStatus;
+                inviterId: string;
+                expiresAt: Date;
+                createdAt: Date;
+            };
+            Member: {
+                id: string;
+                organizationId: string;
+                role: "admin" | "owner" | "member";
+                createdAt: Date;
+                userId: string;
+                user: {
+                    id: string;
+                    email: string;
+                    name: string;
+                    image?: string | undefined;
+                };
+            };
+            Team: any;
+            TeamMember: any;
+            ActiveOrganization: {
+                members: {
+                    id: string;
+                    organizationId: string;
+                    role: "admin" | "owner" | "member";
+                    createdAt: Date;
+                    userId: string;
+                    user: {
+                        id: string;
+                        email: string;
+                        name: string;
+                        image?: string | undefined;
+                    };
+                }[];
+                invitations: {
+                    id: string;
+                    organizationId: string;
+                    email: string;
+                    role: "admin" | "owner" | "member";
+                    status: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).InvitationStatus;
+                    inviterId: string;
+                    expiresAt: Date;
+                    createdAt: Date;
+                }[];
+            } & {
+                id: string;
+                name: string;
+                slug: string;
+                createdAt: Date;
+                logo?: string | null | undefined;
+                metadata?: any;
+            };
+        };
+        $ERROR_CODES: {
+            readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION: "You are not allowed to create a new organization";
+            readonly YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS: "You have reached the maximum number of organizations";
+            readonly ORGANIZATION_ALREADY_EXISTS: "Organization already exists";
+            readonly ORGANIZATION_SLUG_ALREADY_TAKEN: "Organization slug already taken";
+            readonly ORGANIZATION_NOT_FOUND: "Organization not found";
+            readonly USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION: "User is not a member of the organization";
+            readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION: "You are not allowed to update this organization";
+            readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION: "You are not allowed to delete this organization";
+            readonly NO_ACTIVE_ORGANIZATION: "No active organization";
+            readonly USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION: "User is already a member of this organization";
+            readonly MEMBER_NOT_FOUND: "Member not found";
+            readonly ROLE_NOT_FOUND: "Role not found";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM: "You are not allowed to create a new team";
+            readonly TEAM_ALREADY_EXISTS: "Team already exists";
+            readonly TEAM_NOT_FOUND: "Team not found";
+            readonly YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER: "You cannot leave the organization as the only owner";
+            readonly YOU_CANNOT_LEAVE_THE_ORGANIZATION_WITHOUT_AN_OWNER: "You cannot leave the organization without an owner";
+            readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER: "You are not allowed to delete this member";
+            readonly YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION: "You are not allowed to invite users to this organization";
+            readonly USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION: "User is already invited to this organization";
+            readonly INVITATION_NOT_FOUND: "Invitation not found";
+            readonly YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION: "You are not the recipient of the invitation";
+            readonly EMAIL_VERIFICATION_REQUIRED_BEFORE_ACCEPTING_OR_REJECTING_INVITATION: "Email verification required before accepting or rejecting invitation";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION: "You are not allowed to cancel this invitation";
+            readonly INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION: "Inviter is no longer a member of the organization";
+            readonly YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE: "You are not allowed to invite a user with this role";
+            readonly FAILED_TO_RETRIEVE_INVITATION: "Failed to retrieve invitation";
+            readonly YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS: "You have reached the maximum number of teams";
+            readonly UNABLE_TO_REMOVE_LAST_TEAM: "Unable to remove last team";
+            readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER: "You are not allowed to update this member";
+            readonly ORGANIZATION_MEMBERSHIP_LIMIT_REACHED: "Organization membership limit reached";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION: "You are not allowed to create teams in this organization";
+            readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION: "You are not allowed to delete teams in this organization";
+            readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM: "You are not allowed to update this team";
+            readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM: "You are not allowed to delete this team";
+            readonly INVITATION_LIMIT_REACHED: "Invitation limit reached";
+            readonly TEAM_MEMBER_LIMIT_REACHED: "Team member limit reached";
+            readonly USER_IS_NOT_A_MEMBER_OF_THE_TEAM: "User is not a member of the team";
+            readonly YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM: "You are not allowed to list the members of this team";
+            readonly YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM: "You do not have an active team";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER: "You are not allowed to create a new member";
+            readonly YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER: "You are not allowed to remove a team member";
+            readonly YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION: "You are not allowed to access this organization as an owner";
+            readonly YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION: "You are not a member of this organization";
+            readonly MISSING_AC_INSTANCE: "Dynamic Access Control requires a pre-defined ac instance on the server auth plugin. Read server logs for more information";
+            readonly YOU_MUST_BE_IN_AN_ORGANIZATION_TO_CREATE_A_ROLE: "You must be in an organization to create a role";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_A_ROLE: "You are not allowed to create a role";
+            readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_A_ROLE: "You are not allowed to update a role";
+            readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_A_ROLE: "You are not allowed to delete a role";
+            readonly YOU_ARE_NOT_ALLOWED_TO_READ_A_ROLE: "You are not allowed to read a role";
+            readonly YOU_ARE_NOT_ALLOWED_TO_LIST_A_ROLE: "You are not allowed to list a role";
+            readonly YOU_ARE_NOT_ALLOWED_TO_GET_A_ROLE: "You are not allowed to get a role";
+            readonly TOO_MANY_ROLES: "This organization has too many roles";
+            readonly INVALID_RESOURCE: "The provided permission includes an invalid resource";
+            readonly ROLE_NAME_IS_ALREADY_TAKEN: "That role name is already taken";
+            readonly CANNOT_DELETE_A_PRE_DEFINED_ROLE: "Cannot delete a pre-defined role";
+        };
+        options: NoInfer<{
+            allowUserToCreateOrganization: true;
+            creatorRole: string;
+            membershipLimit: number;
+        }>;
+    }, {
+        id: "api-key";
+        $ERROR_CODES: {
+            readonly INVALID_METADATA_TYPE: "metadata must be an object or undefined";
+            readonly REFILL_AMOUNT_AND_INTERVAL_REQUIRED: "refillAmount is required when refillInterval is provided";
+            readonly REFILL_INTERVAL_AND_AMOUNT_REQUIRED: "refillInterval is required when refillAmount is provided";
+            readonly USER_BANNED: "User is banned";
+            readonly UNAUTHORIZED_SESSION: "Unauthorized or invalid session";
+            readonly KEY_NOT_FOUND: "API Key not found";
+            readonly KEY_DISABLED: "API Key is disabled";
+            readonly KEY_EXPIRED: "API Key has expired";
+            readonly USAGE_EXCEEDED: "API Key has reached its usage limit";
+            readonly KEY_NOT_RECOVERABLE: "API Key is not recoverable";
+            readonly EXPIRES_IN_IS_TOO_SMALL: "The expiresIn is smaller than the predefined minimum value.";
+            readonly EXPIRES_IN_IS_TOO_LARGE: "The expiresIn is larger than the predefined maximum value.";
+            readonly INVALID_REMAINING: "The remaining count is either too large or too small.";
+            readonly INVALID_PREFIX_LENGTH: "The prefix length is either too large or too small.";
+            readonly INVALID_NAME_LENGTH: "The name length is either too large or too small.";
+            readonly METADATA_DISABLED: "Metadata is disabled.";
+            readonly RATE_LIMIT_EXCEEDED: "Rate limit exceeded.";
+            readonly NO_VALUES_TO_UPDATE: "No values to update.";
+            readonly KEY_DISABLED_EXPIRATION: "Custom key expiration values are disabled.";
+            readonly INVALID_API_KEY: "Invalid API key.";
+            readonly INVALID_USER_ID_FROM_API_KEY: "The user id from the API key is invalid.";
+            readonly INVALID_API_KEY_GETTER_RETURN_TYPE: "API Key getter returned an invalid key type. Expected string.";
+            readonly SERVER_ONLY_PROPERTY: "The property you're trying to set can only be set from the server auth instance only.";
+            readonly FAILED_TO_UPDATE_API_KEY: "Failed to update API key";
+            readonly NAME_REQUIRED: "API Key name is required.";
+        };
+        hooks: {
+            before: {
+                matcher: (ctx: import("better-auth", { with: { "resolution-mode": "import" } }).HookEndpointContext) => boolean;
+                handler: (inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                    session: {
+                        id: string;
+                        token: string;
+                        userId: string;
+                        userAgent: string | null;
+                        ipAddress: string | null;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        expiresAt: Date;
+                    };
+                } | {
+                    context: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions, import("better-auth", { with: { "resolution-mode": "import" } }).AuthContext & {
+                        returned?: unknown | undefined;
+                        responseHeaders?: Headers | undefined;
+                    }>;
+                }>;
+            }[];
+        };
+        endpoints: {
+            createApiKey: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/api-key/create", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    name: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                    expiresIn: import("better-auth", { with: { "resolution-mode": "import" } }).ZodDefault<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNullable<import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>>>;
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>>;
+                    prefix: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                    remaining: import("better-auth", { with: { "resolution-mode": "import" } }).ZodDefault<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNullable<import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>>>;
+                    metadata: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodAny>;
+                    refillAmount: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    refillInterval: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    rateLimitTimeWindow: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    rateLimitMax: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    rateLimitEnabled: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodBoolean>;
+                    permissions: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodRecord<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodArray<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>>>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                createdAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                updatedAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                prefix: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                start: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                key: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                enabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                expiresAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                userId: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                lastRefillAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRequest: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    additionalProperties: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitMax: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitTimeWindow: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                remaining: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                refillAmount: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                refillInterval: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitEnabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                requestCount: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                permissions: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    additionalProperties: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                key: string;
+                metadata: any;
+                permissions: any;
+                id: string;
+                name: string | null;
+                start: string | null;
+                prefix: string | null;
+                userId: string;
+                refillInterval: number | null;
+                refillAmount: number | null;
+                lastRefillAt: Date | null;
+                enabled: boolean;
+                rateLimitEnabled: boolean;
+                rateLimitTimeWindow: number | null;
+                rateLimitMax: number | null;
+                requestCount: number;
+                remaining: number | null;
+                lastRequest: Date | null;
+                expiresAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+            }>;
+            verifyApiKey: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<string, {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    key: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                    permissions: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodRecord<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodArray<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>>>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+            }, {
+                valid: boolean;
+                error: {
+                    message: string | undefined;
+                    code: string;
+                };
+                key: null;
+            } | {
+                valid: boolean;
+                error: null;
+                key: Omit<import("better-auth/plugins", { with: { "resolution-mode": "import" } }).ApiKey, "key"> | null;
+            }>;
+            getApiKey: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/api-key/get", {
+                method: "GET";
+                query: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    id: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).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: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                start: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                prefix: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                userId: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                refillInterval: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                refillAmount: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRefillAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                enabled: {
+                                                    type: string;
+                                                    description: string;
+                                                    default: boolean;
+                                                };
+                                                rateLimitEnabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                rateLimitTimeWindow: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitMax: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                requestCount: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                remaining: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRequest: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                expiresAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                createdAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                updatedAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    additionalProperties: boolean;
+                                                    description: string;
+                                                };
+                                                permissions: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                permissions: {
+                    [key: string]: string[];
+                } | null;
+                id: string;
+                name: string | null;
+                start: string | null;
+                prefix: string | null;
+                userId: string;
+                refillInterval: number | null;
+                refillAmount: number | null;
+                lastRefillAt: Date | null;
+                enabled: boolean;
+                rateLimitEnabled: boolean;
+                rateLimitTimeWindow: number | null;
+                rateLimitMax: number | null;
+                requestCount: number;
+                remaining: number | null;
+                lastRequest: Date | null;
+                expiresAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+                metadata: Record<string, any> | null;
+            }>;
+            updateApiKey: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/api-key/update", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    keyId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                    userId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodCoercedString<unknown>>;
+                    name: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>;
+                    enabled: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodBoolean>;
+                    remaining: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    refillAmount: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    refillInterval: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    metadata: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodAny>;
+                    expiresIn: import("better-auth", { with: { "resolution-mode": "import" } }).ZodNullable<import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>>;
+                    rateLimitEnabled: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodBoolean>;
+                    rateLimitTimeWindow: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    rateLimitMax: import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodNumber>;
+                    permissions: import("better-auth", { with: { "resolution-mode": "import" } }).ZodNullable<import("better-auth", { with: { "resolution-mode": "import" } }).ZodOptional<import("better-auth", { with: { "resolution-mode": "import" } }).ZodRecord<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString, import("better-auth", { with: { "resolution-mode": "import" } }).ZodArray<import("better-auth", { with: { "resolution-mode": "import" } }).ZodString>>>>;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                start: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                prefix: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                userId: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                refillInterval: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                refillAmount: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRefillAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                enabled: {
+                                                    type: string;
+                                                    description: string;
+                                                    default: boolean;
+                                                };
+                                                rateLimitEnabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                rateLimitTimeWindow: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitMax: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                requestCount: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                remaining: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRequest: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                expiresAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                createdAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                updatedAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    additionalProperties: boolean;
+                                                    description: string;
+                                                };
+                                                permissions: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                permissions: {
+                    [key: string]: string[];
+                } | null;
+                id: string;
+                name: string | null;
+                start: string | null;
+                prefix: string | null;
+                userId: string;
+                refillInterval: number | null;
+                refillAmount: number | null;
+                lastRefillAt: Date | null;
+                enabled: boolean;
+                rateLimitEnabled: boolean;
+                rateLimitTimeWindow: number | null;
+                rateLimitMax: number | null;
+                requestCount: number;
+                remaining: number | null;
+                lastRequest: Date | null;
+                expiresAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+                metadata: Record<string, any> | null;
+            }>;
+            deleteApiKey: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/api-key/delete", {
+                method: "POST";
+                body: import("better-auth", { with: { "resolution-mode": "import" } }).ZodObject<{
+                    keyId: import("better-auth", { with: { "resolution-mode": "import" } }).ZodString;
+                }, import("better-auth", { with: { "resolution-mode": "import" } }).$strip>;
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).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: {
+                        description: string;
+                        requestBody: {
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            keyId: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                        };
+                                        required: string[];
+                                    };
+                                };
+                            };
+                        };
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            listApiKeys: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/api-key/list", {
+                method: "GET";
+                use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).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: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "array";
+                                            items: {
+                                                type: string;
+                                                properties: {
+                                                    id: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    name: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    start: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    prefix: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    userId: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    refillInterval: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    refillAmount: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    lastRefillAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    enabled: {
+                                                        type: string;
+                                                        description: string;
+                                                        default: boolean;
+                                                    };
+                                                    rateLimitEnabled: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    rateLimitTimeWindow: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    rateLimitMax: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    requestCount: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    remaining: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    lastRequest: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    expiresAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    createdAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        description: string;
+                                                    };
+                                                    updatedAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        description: string;
+                                                    };
+                                                    metadata: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        additionalProperties: boolean;
+                                                        description: string;
+                                                    };
+                                                    permissions: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                permissions: {
+                    [key: string]: string[];
+                } | null;
+                id: string;
+                name: string | null;
+                start: string | null;
+                prefix: string | null;
+                userId: string;
+                refillInterval: number | null;
+                refillAmount: number | null;
+                lastRefillAt: Date | null;
+                enabled: boolean;
+                rateLimitEnabled: boolean;
+                rateLimitTimeWindow: number | null;
+                rateLimitMax: number | null;
+                requestCount: number;
+                remaining: number | null;
+                lastRequest: Date | null;
+                expiresAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+                metadata: Record<string, any> | null;
+            }[]>;
+            deleteAllExpiredApiKeys: import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<string, {
+                method: "POST";
+            }, {
+                success: boolean;
+                error: unknown;
+            }>;
+        };
+        schema: {
+            apikey: {
+                fields: {
+                    name: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    start: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    prefix: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    key: {
+                        type: "string";
+                        required: true;
+                        input: false;
+                        index: true;
+                    };
+                    userId: {
+                        type: "string";
+                        references: {
+                            model: string;
+                            field: string;
+                            onDelete: "cascade";
+                        };
+                        required: true;
+                        input: false;
+                        index: true;
+                    };
+                    refillInterval: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    refillAmount: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    lastRefillAt: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    enabled: {
+                        type: "boolean";
+                        required: false;
+                        input: false;
+                        defaultValue: true;
+                    };
+                    rateLimitEnabled: {
+                        type: "boolean";
+                        required: false;
+                        input: false;
+                        defaultValue: true;
+                    };
+                    rateLimitTimeWindow: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    rateLimitMax: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    requestCount: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    remaining: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    lastRequest: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                        input: false;
+                    };
+                    updatedAt: {
+                        type: "date";
+                        required: true;
+                        input: false;
+                    };
+                    permissions: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    metadata: {
+                        type: "string";
+                        required: false;
+                        input: true;
+                        transform: {
+                            input(value: import("better-auth", { with: { "resolution-mode": "import" } }).DBPrimitive): string;
+                            output(value: import("better-auth", { with: { "resolution-mode": "import" } }).DBPrimitive): any;
+                        };
+                    };
+                };
+            };
+        };
+        options: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).ApiKeyOptions | undefined;
+    }];
+    databaseHooks: {
+        user: {
+            create: {
+                after: (user: any) => Promise<void>;
+            };
+        };
+    };
+}>;
+/**
+ * Export the auth instance type for use in other modules
+ */
+export type BetterAuthInstance = ReturnType<typeof createBetterAuthInstance>;
+//# sourceMappingURL=better-auth-instance.d.ts.map