rimecms 0.31.5 → 0.32.1

package/dist/core/boot.server.d.ts

@@ -0,0 +1,4227 @@
+import type { Config } from './config/types.js';
+import type { BuildConfig } from './config/index.server.js';
+/**
+ * Phase 2 of three — everything that happens once, when the process starts.
+ *
+ * A numbered sequence rather than a list of uniform steps, because each one feeds the next: the
+ * config context feeds the adapter, the adapter feeds better-auth. Two of those dependencies —
+ * schema before adapter, adapter before better-auth — are load-bearing and invisible anywhere
+ * else, which is why the order is written out.
+ */
+export declare const bootRime: <const C extends Config>(config: BuildConfig<C>) => Promise<{
+    plugins: BuildConfig<C>["$InferPluginsServer"];
+    configCtx: {
+        readonly raw: BuildConfig<C>;
+        readonly collections: C extends {
+            collections?: readonly any[];
+        } ? { [K in NonNullable<C["collections"]>[number] as K extends {
+            slug: infer N;
+        } ? N extends string ? N : never : never]: K; } : Record<string, never>;
+        readonly areas: C extends {
+            areas?: readonly any[];
+        } ? { [K in NonNullable<C["areas"]>[number] as K extends {
+            slug: infer N;
+        } ? N extends string ? N : never : never]: K; } : Record<string, never>;
+        readonly prototypes: (import("./config/types.js").BuiltCollection | import("./config/types.js").BuiltArea)[];
+        getDefaultLocale(): string | undefined;
+        getLocalesCodes: () => string[];
+        isValidLocale: (locale: string) => boolean;
+        getArea: (slug: string) => import("./config/types.js").BuiltArea;
+        getCollection: (slug: string) => import("./config/types.js").BuiltCollection;
+        getBySlug: (slug: string) => import("./config/types.js").BuiltCollection | import("./config/types.js").BuiltArea;
+        isCollection: (slug?: string) => slug is import("./prototype/types.js").CollectionSlug;
+        isArea: (slug?: string) => slug is import("./prototype/types.js").AreaSlug;
+        getDocumentPrototype(slug: import("./prototype/types.js").PrototypeSlug): "area" | "collection";
+    };
+    adapter: import("./adapter.js").Adapter;
+    auth: import("better-auth").Auth<{
+        plugins: ({
+            id: "api-key";
+            version: string;
+            $ERROR_CODES: {
+                INVALID_METADATA_TYPE: import("better-auth").RawError<"INVALID_METADATA_TYPE">;
+                REFILL_AMOUNT_AND_INTERVAL_REQUIRED: import("better-auth").RawError<"REFILL_AMOUNT_AND_INTERVAL_REQUIRED">;
+                REFILL_INTERVAL_AND_AMOUNT_REQUIRED: import("better-auth").RawError<"REFILL_INTERVAL_AND_AMOUNT_REQUIRED">;
+                USER_BANNED: import("better-auth").RawError<"USER_BANNED">;
+                UNAUTHORIZED_SESSION: import("better-auth").RawError<"UNAUTHORIZED_SESSION">;
+                KEY_NOT_FOUND: import("better-auth").RawError<"KEY_NOT_FOUND">;
+                KEY_DISABLED: import("better-auth").RawError<"KEY_DISABLED">;
+                KEY_EXPIRED: import("better-auth").RawError<"KEY_EXPIRED">;
+                USAGE_EXCEEDED: import("better-auth").RawError<"USAGE_EXCEEDED">;
+                KEY_NOT_RECOVERABLE: import("better-auth").RawError<"KEY_NOT_RECOVERABLE">;
+                EXPIRES_IN_IS_TOO_SMALL: import("better-auth").RawError<"EXPIRES_IN_IS_TOO_SMALL">;
+                EXPIRES_IN_IS_TOO_LARGE: import("better-auth").RawError<"EXPIRES_IN_IS_TOO_LARGE">;
+                INVALID_REMAINING: import("better-auth").RawError<"INVALID_REMAINING">;
+                INVALID_PREFIX_LENGTH: import("better-auth").RawError<"INVALID_PREFIX_LENGTH">;
+                INVALID_NAME_LENGTH: import("better-auth").RawError<"INVALID_NAME_LENGTH">;
+                METADATA_DISABLED: import("better-auth").RawError<"METADATA_DISABLED">;
+                RATE_LIMIT_EXCEEDED: import("better-auth").RawError<"RATE_LIMIT_EXCEEDED">;
+                NO_VALUES_TO_UPDATE: import("better-auth").RawError<"NO_VALUES_TO_UPDATE">;
+                KEY_DISABLED_EXPIRATION: import("better-auth").RawError<"KEY_DISABLED_EXPIRATION">;
+                INVALID_API_KEY: import("better-auth").RawError<"INVALID_API_KEY">;
+                INVALID_USER_ID_FROM_API_KEY: import("better-auth").RawError<"INVALID_USER_ID_FROM_API_KEY">;
+                INVALID_REFERENCE_ID_FROM_API_KEY: import("better-auth").RawError<"INVALID_REFERENCE_ID_FROM_API_KEY">;
+                INVALID_API_KEY_GETTER_RETURN_TYPE: import("better-auth").RawError<"INVALID_API_KEY_GETTER_RETURN_TYPE">;
+                SERVER_ONLY_PROPERTY: import("better-auth").RawError<"SERVER_ONLY_PROPERTY">;
+                FAILED_TO_UPDATE_API_KEY: import("better-auth").RawError<"FAILED_TO_UPDATE_API_KEY">;
+                NAME_REQUIRED: import("better-auth").RawError<"NAME_REQUIRED">;
+                ORGANIZATION_ID_REQUIRED: import("better-auth").RawError<"ORGANIZATION_ID_REQUIRED">;
+                USER_NOT_MEMBER_OF_ORGANIZATION: import("better-auth").RawError<"USER_NOT_MEMBER_OF_ORGANIZATION">;
+                INSUFFICIENT_API_KEY_PERMISSIONS: import("better-auth").RawError<"INSUFFICIENT_API_KEY_PERMISSIONS">;
+                NO_DEFAULT_API_KEY_CONFIGURATION_FOUND: import("better-auth").RawError<"NO_DEFAULT_API_KEY_CONFIGURATION_FOUND">;
+                ORGANIZATION_PLUGIN_REQUIRED: import("better-auth").RawError<"ORGANIZATION_PLUGIN_REQUIRED">;
+            };
+            hooks: {
+                before: {
+                    matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
+                    handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").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-call").MiddlewareContext<import("better-call").MiddlewareOptions, import("better-auth").PluginContext<import("better-auth").BetterAuthOptions> & import("better-auth").InfoContext & {
+                            options: import("better-auth").BetterAuthOptions;
+                            trustedOrigins: string[];
+                            trustedProviders: string[];
+                            isTrustedOrigin: (url: string, settings?: {
+                                allowRelativePaths: boolean;
+                            }) => boolean;
+                            oauthConfig: {
+                                skipStateCookieCheck?: boolean | undefined;
+                                storeStateStrategy: "database" | "cookie";
+                            };
+                            newSession: {
+                                session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, any>;
+                                user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, any>;
+                            } | null;
+                            session: {
+                                session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, any>;
+                                user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, any>;
+                            } | null;
+                            setNewSession: (session: {
+                                session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, any>;
+                                user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, any>;
+                            } | null) => void;
+                            socialProviders: import("better-auth").OAuthProvider[];
+                            authCookies: import("better-auth").BetterAuthCookies;
+                            logger: ReturnType<(options?: import("better-auth").Logger | undefined) => import("better-auth").InternalLogger>;
+                            rateLimit: {
+                                enabled: boolean;
+                                window: number;
+                                max: number;
+                                storage: "memory" | "database" | "secondary-storage";
+                            } & Omit<import("better-auth").BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+                            adapter: import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
+                            checkSchema?: import("@better-auth/core/db/internal").SchemaCheck | undefined;
+                            internalAdapter: import("better-auth").InternalAdapter<import("better-auth").BetterAuthOptions>;
+                            createAuthCookie: (cookieName: string, overrideAttributes?: Partial<import("better-call").CookieOptions> | undefined) => import("better-auth").BetterAuthCookie;
+                            secret: string;
+                            secretConfig: string | import("better-auth").SecretConfig;
+                            sessionConfig: {
+                                updateAge: number;
+                                expiresIn: number;
+                                freshAge: number;
+                                cookieCacheSigner?: import("better-auth").CookieCacheSigner | undefined;
+                                cookieRefreshCache: false | {
+                                    enabled: true;
+                                    updateAge: number;
+                                };
+                            };
+                            generateId: (options: {
+                                model: import("better-auth").ModelNames;
+                                size?: number | undefined;
+                            }) => string | false;
+                            secondaryStorage: import("better-auth").SecondaryStorage | undefined;
+                            password: {
+                                hash: (password: string) => Promise<string>;
+                                verify: (data: {
+                                    password: string;
+                                    hash: string;
+                                }) => Promise<boolean>;
+                                config: {
+                                    minPasswordLength: number;
+                                    maxPasswordLength: number;
+                                };
+                                checkPassword: (userId: string, ctx: import("better-auth").GenericEndpointContext<import("better-auth").BetterAuthOptions>) => Promise<boolean>;
+                            };
+                            tables: import("better-auth").BetterAuthDBSchema;
+                            runMigrations: () => Promise<void>;
+                            publishTelemetry: (event: {
+                                type: string;
+                                anonymousId?: string | undefined;
+                                payload: Record<string, any>;
+                            }) => Promise<void>;
+                            skipOriginCheck: boolean | string[];
+                            skipCSRFCheck: boolean;
+                            runInBackground: (promise: Promise<unknown>) => void;
+                            runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("better-auth").Awaitable<unknown>;
+                        } & {
+                            returned?: unknown | undefined;
+                            responseHeaders?: Headers | undefined;
+                        }>;
+                    }>>;
+                }[];
+            };
+            endpoints: {
+                createApiKey: import("better-call").StrictEndpoint<"/api-key/create", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        name: import("zod").ZodOptional<import("zod").ZodString>;
+                        expiresIn: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>>;
+                        prefix: import("zod").ZodOptional<import("zod").ZodString>;
+                        remaining: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>>;
+                        metadata: import("zod").ZodOptional<import("zod").ZodAny>;
+                        refillAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        refillInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        rateLimitTimeWindow: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        rateLimitMax: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        rateLimitEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        permissions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>;
+                        userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                        organizationId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                    }, import("zod/v4/core").$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;
+                                                    };
+                                                    referenceId: {
+                                                        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;
+                    configId: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    referenceId: 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-call").StrictEndpoint<string, {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        key: import("zod").ZodString;
+                        permissions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>;
+                    }, import("zod/v4/core").$strip>;
+                }, {
+                    valid: boolean;
+                    error: {
+                        message: import("better-auth").RawError<"INVALID_API_KEY">;
+                        code: "KEY_NOT_FOUND";
+                    };
+                    key: null;
+                } | {
+                    valid: boolean;
+                    error: {
+                        message: string | undefined;
+                        code: string;
+                        cause?: unknown;
+                    };
+                    key: null;
+                } | {
+                    valid: boolean;
+                    error: {
+                        message: import("better-auth").RawError<"INVALID_API_KEY">;
+                        code: "INVALID_API_KEY";
+                    };
+                    key: null;
+                } | {
+                    valid: boolean;
+                    error: null;
+                    key: Omit<import("@better-auth/api-key").ApiKey, "key"> | null;
+                }>;
+                getApiKey: import("better-call").StrictEndpoint<"/api-key/get", {
+                    method: "GET";
+                    query: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        id: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").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[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    metadata: Record<string, any> | null;
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    configId: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    referenceId: 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;
+                }>;
+                updateApiKey: import("better-call").StrictEndpoint<"/api-key/update", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        keyId: import("zod").ZodString;
+                        userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                        name: import("zod").ZodOptional<import("zod").ZodString>;
+                        enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        remaining: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        refillAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        refillInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        metadata: import("zod").ZodOptional<import("zod").ZodAny>;
+                        expiresIn: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                        rateLimitEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        rateLimitTimeWindow: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        rateLimitMax: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        permissions: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>>;
+                    }, import("zod/v4/core").$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[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    metadata: Record<string, any> | null;
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    configId: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    referenceId: 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;
+                }>;
+                deleteApiKey: import("better-call").StrictEndpoint<"/api-key/delete", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        keyId: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").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-call").StrictEndpoint<"/api-key/list", {
+                    method: "GET";
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                            };
+                        };
+                    }>>[];
+                    query: import("zod").ZodOptional<import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        organizationId: import("zod").ZodOptional<import("zod").ZodString>;
+                        limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                        offset: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                        sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+                        sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>>;
+                    }, import("zod/v4/core").$strip>>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    apiKeys: {
+                                                        type: string;
+                                                        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[];
+                                                        };
+                                                    };
+                                                    total: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    limit: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    offset: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    apiKeys: {
+                        metadata: Record<string, any> | null;
+                        permissions: {
+                            [key: string]: string[];
+                        } | null;
+                        id: string;
+                        configId: string;
+                        name: string | null;
+                        start: string | null;
+                        prefix: string | null;
+                        referenceId: 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;
+                    }[];
+                    total: number;
+                    limit: number | undefined;
+                    offset: number | undefined;
+                }>;
+                deleteAllExpiredApiKeys: import("better-call").StrictEndpoint<string, {
+                    method: "POST";
+                }, {
+                    success: boolean;
+                    error: unknown;
+                }>;
+            };
+            schema: {
+                apikey: {
+                    fields: {
+                        configId: {
+                            type: "string";
+                            required: true;
+                            defaultValue: string;
+                            input: false;
+                            index: true;
+                        };
+                        name: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        start: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        referenceId: {
+                            type: "string";
+                            required: true;
+                            input: false;
+                            index: true;
+                        };
+                        prefix: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        key: {
+                            type: "string";
+                            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").DBPrimitive): string;
+                                output(value: import("better-auth").DBPrimitive): any;
+                            };
+                        };
+                    };
+                };
+            };
+        } | {
+            id: "admin";
+            version: string;
+            init(): {
+                options: {
+                    databaseHooks: {
+                        user: {
+                            create: {
+                                before(user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, unknown>): Promise<{
+                                    data: {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        email: string;
+                                        emailVerified: boolean;
+                                        name: string;
+                                        image?: string | null | undefined;
+                                        role: string;
+                                    };
+                                }>;
+                            };
+                        };
+                        session: {
+                            create: {
+                                before(session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, unknown>, ctx: import("better-auth").GenericEndpointContext | null): Promise<void>;
+                            };
+                        };
+                    };
+                };
+            };
+            hooks: {
+                after: {
+                    matcher(context: import("better-auth").HookEndpointContext): boolean;
+                    handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>>;
+                }[];
+            };
+            endpoints: {
+                setRole: import("better-call").StrictEndpoint<"/admin/set-role", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        role: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
+                    }, import("zod/v4/core").$strip>;
+                    requireHeaders: true;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                userId: string;
+                                role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                getUser: import("better-call").StrictEndpoint<"/admin/get-user", {
+                    method: "GET";
+                    query: import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import("better-auth/plugins").UserWithRole>;
+                createUser: import("better-call").StrictEndpoint<"/admin/create-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        password: import("zod").ZodOptional<import("zod").ZodString>;
+                        name: import("zod").ZodString;
+                        role: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+                        data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                email: string;
+                                password?: string | undefined;
+                                name: string;
+                                role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
+                                data?: Record<string, any> | undefined;
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                adminUpdateUser: import("better-call").StrictEndpoint<"/admin/update-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        data: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import("better-auth/plugins").UserWithRole>;
+                listUsers: import("better-call").StrictEndpoint<"/admin/list-users", {
+                    method: "GET";
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    query: import("zod").ZodObject<{
+                        searchValue: import("zod").ZodOptional<import("zod").ZodString>;
+                        searchField: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            email: "email";
+                            name: "name";
+                        }>>;
+                        searchOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            contains: "contains";
+                            starts_with: "starts_with";
+                            ends_with: "ends_with";
+                        }>>;
+                        limit: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                        offset: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                        sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+                        sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>>;
+                        filterField: import("zod").ZodOptional<import("zod").ZodString>;
+                        filterValue: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, import("zod").ZodBoolean]>, import("zod").ZodArray<import("zod").ZodString>]>, import("zod").ZodArray<import("zod").ZodNumber>]>>;
+                        filterOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            eq: "eq";
+                            ne: "ne";
+                            gt: "gt";
+                            gte: "gte";
+                            lt: "lt";
+                            lte: "lte";
+                            in: "in";
+                            not_in: "not_in";
+                            contains: "contains";
+                            starts_with: "starts_with";
+                            ends_with: "ends_with";
+                        }>>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    users: {
+                                                        type: string;
+                                                        items: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                    total: {
+                                                        type: string;
+                                                    };
+                                                    limit: {
+                                                        type: string;
+                                                    };
+                                                    offset: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    users: import("better-auth/plugins").UserWithRole[];
+                    total: number;
+                }>;
+                listUserSessions: import("better-call").StrictEndpoint<"/admin/list-user-sessions", {
+                    method: "POST";
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    sessions: {
+                                                        type: string;
+                                                        items: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
+                }>;
+                unbanUser: import("better-call").StrictEndpoint<"/admin/unban-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                banUser: import("better-call").StrictEndpoint<"/admin/ban-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        banReason: import("zod").ZodOptional<import("zod").ZodString>;
+                        banExpiresIn: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                impersonateUser: import("better-call").StrictEndpoint<"/admin/impersonate-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    session: {
+                                                        $ref: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                stopImpersonating: import("better-call").StrictEndpoint<"/admin/stop-impersonating", {
+                    method: "POST";
+                    requireHeaders: true;
+                }, {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    } & Record<string, any>;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    } & Record<string, any>;
+                }>;
+                revokeUserSession: import("better-call").StrictEndpoint<"/admin/revoke-user-session", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        sessionToken: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                revokeUserSessions: import("better-call").StrictEndpoint<"/admin/revoke-user-sessions", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                removeUser: import("better-call").StrictEndpoint<"/admin/remove-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                setUserPassword: import("better-call").StrictEndpoint<"/admin/set-user-password", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        newPassword: import("zod").ZodString;
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    status: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    status: boolean;
+                }>;
+                userHasPermission: import("better-call").StrictEndpoint<"/admin/has-permission", {
+                    method: "POST";
+                    body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                        userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                        role: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodXor<readonly [import("zod").ZodObject<{
+                        permission: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        permissions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                    }, import("zod/v4/core").$strip>]>>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            requestBody: {
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                permissions: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    error: {
+                                                        type: string;
+                                                    };
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                permissions: {
+                                    readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "impersonate-admins" | "set-password" | "set-email")[] | undefined;
+                                    readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                                };
+                            } & {
+                                userId?: string | undefined;
+                                role?: "user" | "admin" | "staff" | undefined;
+                            };
+                        };
+                    };
+                }, {
+                    error: null;
+                    success: boolean;
+                }>;
+            };
+            $ERROR_CODES: {
+                USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: import("better-auth").RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+                FAILED_TO_CREATE_USER: import("better-auth").RawError<"FAILED_TO_CREATE_USER">;
+                USER_ALREADY_EXISTS: import("better-auth").RawError<"USER_ALREADY_EXISTS">;
+                YOU_CANNOT_BAN_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_BAN_YOURSELF">;
+                YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+                YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+                YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+                YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+                BANNED_USER: import("better-auth").RawError<"BANNED_USER">;
+                YOU_ARE_NOT_ALLOWED_TO_GET_USER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+                NO_DATA_TO_UPDATE: import("better-auth").RawError<"NO_DATA_TO_UPDATE">;
+                YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+                YOU_CANNOT_REMOVE_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+                YOU_CANNOT_IMPERSONATE_ADMINS: import("better-auth").RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+                INVALID_ROLE_TYPE: import("better-auth").RawError<"INVALID_ROLE_TYPE">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL">;
+                PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER: import("better-auth").RawError<"PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER">;
+            };
+            schema: {
+                user: {
+                    fields: {
+                        role: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        banned: {
+                            type: "boolean";
+                            defaultValue: false;
+                            required: false;
+                            input: false;
+                        };
+                        banReason: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        banExpires: {
+                            type: "date";
+                            required: false;
+                            input: false;
+                        };
+                    };
+                };
+                session: {
+                    fields: {
+                        impersonatedBy: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                    };
+                };
+            };
+            options: NoInfer<{
+                accessControl: {
+                    newRole<const TRoleStatements extends import("better-auth/plugins").Statements>(statements: import("better-auth/plugins").RoleInput<{
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }, TRoleStatements>): import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<TRoleStatements>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                    statements: {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    };
+                };
+                roles: {
+                    admin: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<import("better-auth/plugins").ExactRoleStatements<{
+                        readonly user: ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: ["list", "revoke", "delete"];
+                    }>>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                    user: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<import("better-auth/plugins").ExactRoleStatements<{
+                        readonly user: [];
+                        readonly session: [];
+                    }>>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                    staff: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+                        readonly user: ["create", "list", "delete"];
+                    }>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                };
+            }>;
+        })[] | [...({
+            id: "api-key";
+            version: string;
+            $ERROR_CODES: {
+                INVALID_METADATA_TYPE: import("better-auth").RawError<"INVALID_METADATA_TYPE">;
+                REFILL_AMOUNT_AND_INTERVAL_REQUIRED: import("better-auth").RawError<"REFILL_AMOUNT_AND_INTERVAL_REQUIRED">;
+                REFILL_INTERVAL_AND_AMOUNT_REQUIRED: import("better-auth").RawError<"REFILL_INTERVAL_AND_AMOUNT_REQUIRED">;
+                USER_BANNED: import("better-auth").RawError<"USER_BANNED">;
+                UNAUTHORIZED_SESSION: import("better-auth").RawError<"UNAUTHORIZED_SESSION">;
+                KEY_NOT_FOUND: import("better-auth").RawError<"KEY_NOT_FOUND">;
+                KEY_DISABLED: import("better-auth").RawError<"KEY_DISABLED">;
+                KEY_EXPIRED: import("better-auth").RawError<"KEY_EXPIRED">;
+                USAGE_EXCEEDED: import("better-auth").RawError<"USAGE_EXCEEDED">;
+                KEY_NOT_RECOVERABLE: import("better-auth").RawError<"KEY_NOT_RECOVERABLE">;
+                EXPIRES_IN_IS_TOO_SMALL: import("better-auth").RawError<"EXPIRES_IN_IS_TOO_SMALL">;
+                EXPIRES_IN_IS_TOO_LARGE: import("better-auth").RawError<"EXPIRES_IN_IS_TOO_LARGE">;
+                INVALID_REMAINING: import("better-auth").RawError<"INVALID_REMAINING">;
+                INVALID_PREFIX_LENGTH: import("better-auth").RawError<"INVALID_PREFIX_LENGTH">;
+                INVALID_NAME_LENGTH: import("better-auth").RawError<"INVALID_NAME_LENGTH">;
+                METADATA_DISABLED: import("better-auth").RawError<"METADATA_DISABLED">;
+                RATE_LIMIT_EXCEEDED: import("better-auth").RawError<"RATE_LIMIT_EXCEEDED">;
+                NO_VALUES_TO_UPDATE: import("better-auth").RawError<"NO_VALUES_TO_UPDATE">;
+                KEY_DISABLED_EXPIRATION: import("better-auth").RawError<"KEY_DISABLED_EXPIRATION">;
+                INVALID_API_KEY: import("better-auth").RawError<"INVALID_API_KEY">;
+                INVALID_USER_ID_FROM_API_KEY: import("better-auth").RawError<"INVALID_USER_ID_FROM_API_KEY">;
+                INVALID_REFERENCE_ID_FROM_API_KEY: import("better-auth").RawError<"INVALID_REFERENCE_ID_FROM_API_KEY">;
+                INVALID_API_KEY_GETTER_RETURN_TYPE: import("better-auth").RawError<"INVALID_API_KEY_GETTER_RETURN_TYPE">;
+                SERVER_ONLY_PROPERTY: import("better-auth").RawError<"SERVER_ONLY_PROPERTY">;
+                FAILED_TO_UPDATE_API_KEY: import("better-auth").RawError<"FAILED_TO_UPDATE_API_KEY">;
+                NAME_REQUIRED: import("better-auth").RawError<"NAME_REQUIRED">;
+                ORGANIZATION_ID_REQUIRED: import("better-auth").RawError<"ORGANIZATION_ID_REQUIRED">;
+                USER_NOT_MEMBER_OF_ORGANIZATION: import("better-auth").RawError<"USER_NOT_MEMBER_OF_ORGANIZATION">;
+                INSUFFICIENT_API_KEY_PERMISSIONS: import("better-auth").RawError<"INSUFFICIENT_API_KEY_PERMISSIONS">;
+                NO_DEFAULT_API_KEY_CONFIGURATION_FOUND: import("better-auth").RawError<"NO_DEFAULT_API_KEY_CONFIGURATION_FOUND">;
+                ORGANIZATION_PLUGIN_REQUIRED: import("better-auth").RawError<"ORGANIZATION_PLUGIN_REQUIRED">;
+            };
+            hooks: {
+                before: {
+                    matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
+                    handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").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-call").MiddlewareContext<import("better-call").MiddlewareOptions, import("better-auth").PluginContext<import("better-auth").BetterAuthOptions> & import("better-auth").InfoContext & {
+                            options: import("better-auth").BetterAuthOptions;
+                            trustedOrigins: string[];
+                            trustedProviders: string[];
+                            isTrustedOrigin: (url: string, settings?: {
+                                allowRelativePaths: boolean;
+                            }) => boolean;
+                            oauthConfig: {
+                                skipStateCookieCheck?: boolean | undefined;
+                                storeStateStrategy: "database" | "cookie";
+                            };
+                            newSession: {
+                                session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, any>;
+                                user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, any>;
+                            } | null;
+                            session: {
+                                session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, any>;
+                                user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, any>;
+                            } | null;
+                            setNewSession: (session: {
+                                session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, any>;
+                                user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, any>;
+                            } | null) => void;
+                            socialProviders: import("better-auth").OAuthProvider[];
+                            authCookies: import("better-auth").BetterAuthCookies;
+                            logger: ReturnType<(options?: import("better-auth").Logger | undefined) => import("better-auth").InternalLogger>;
+                            rateLimit: {
+                                enabled: boolean;
+                                window: number;
+                                max: number;
+                                storage: "memory" | "database" | "secondary-storage";
+                            } & Omit<import("better-auth").BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+                            adapter: import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
+                            checkSchema?: import("@better-auth/core/db/internal").SchemaCheck | undefined;
+                            internalAdapter: import("better-auth").InternalAdapter<import("better-auth").BetterAuthOptions>;
+                            createAuthCookie: (cookieName: string, overrideAttributes?: Partial<import("better-call").CookieOptions> | undefined) => import("better-auth").BetterAuthCookie;
+                            secret: string;
+                            secretConfig: string | import("better-auth").SecretConfig;
+                            sessionConfig: {
+                                updateAge: number;
+                                expiresIn: number;
+                                freshAge: number;
+                                cookieCacheSigner?: import("better-auth").CookieCacheSigner | undefined;
+                                cookieRefreshCache: false | {
+                                    enabled: true;
+                                    updateAge: number;
+                                };
+                            };
+                            generateId: (options: {
+                                model: import("better-auth").ModelNames;
+                                size?: number | undefined;
+                            }) => string | false;
+                            secondaryStorage: import("better-auth").SecondaryStorage | undefined;
+                            password: {
+                                hash: (password: string) => Promise<string>;
+                                verify: (data: {
+                                    password: string;
+                                    hash: string;
+                                }) => Promise<boolean>;
+                                config: {
+                                    minPasswordLength: number;
+                                    maxPasswordLength: number;
+                                };
+                                checkPassword: (userId: string, ctx: import("better-auth").GenericEndpointContext<import("better-auth").BetterAuthOptions>) => Promise<boolean>;
+                            };
+                            tables: import("better-auth").BetterAuthDBSchema;
+                            runMigrations: () => Promise<void>;
+                            publishTelemetry: (event: {
+                                type: string;
+                                anonymousId?: string | undefined;
+                                payload: Record<string, any>;
+                            }) => Promise<void>;
+                            skipOriginCheck: boolean | string[];
+                            skipCSRFCheck: boolean;
+                            runInBackground: (promise: Promise<unknown>) => void;
+                            runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("better-auth").Awaitable<unknown>;
+                        } & {
+                            returned?: unknown | undefined;
+                            responseHeaders?: Headers | undefined;
+                        }>;
+                    }>>;
+                }[];
+            };
+            endpoints: {
+                createApiKey: import("better-call").StrictEndpoint<"/api-key/create", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        name: import("zod").ZodOptional<import("zod").ZodString>;
+                        expiresIn: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>>;
+                        prefix: import("zod").ZodOptional<import("zod").ZodString>;
+                        remaining: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>>;
+                        metadata: import("zod").ZodOptional<import("zod").ZodAny>;
+                        refillAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        refillInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        rateLimitTimeWindow: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        rateLimitMax: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        rateLimitEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        permissions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>;
+                        userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                        organizationId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                    }, import("zod/v4/core").$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;
+                                                    };
+                                                    referenceId: {
+                                                        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;
+                    configId: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    referenceId: 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-call").StrictEndpoint<string, {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        key: import("zod").ZodString;
+                        permissions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>;
+                    }, import("zod/v4/core").$strip>;
+                }, {
+                    valid: boolean;
+                    error: {
+                        message: import("better-auth").RawError<"INVALID_API_KEY">;
+                        code: "KEY_NOT_FOUND";
+                    };
+                    key: null;
+                } | {
+                    valid: boolean;
+                    error: {
+                        message: string | undefined;
+                        code: string;
+                        cause?: unknown;
+                    };
+                    key: null;
+                } | {
+                    valid: boolean;
+                    error: {
+                        message: import("better-auth").RawError<"INVALID_API_KEY">;
+                        code: "INVALID_API_KEY";
+                    };
+                    key: null;
+                } | {
+                    valid: boolean;
+                    error: null;
+                    key: Omit<import("@better-auth/api-key").ApiKey, "key"> | null;
+                }>;
+                getApiKey: import("better-call").StrictEndpoint<"/api-key/get", {
+                    method: "GET";
+                    query: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        id: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").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[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    metadata: Record<string, any> | null;
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    configId: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    referenceId: 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;
+                }>;
+                updateApiKey: import("better-call").StrictEndpoint<"/api-key/update", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        keyId: import("zod").ZodString;
+                        userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                        name: import("zod").ZodOptional<import("zod").ZodString>;
+                        enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        remaining: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        refillAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        refillInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        metadata: import("zod").ZodOptional<import("zod").ZodAny>;
+                        expiresIn: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                        rateLimitEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        rateLimitTimeWindow: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        rateLimitMax: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        permissions: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>>;
+                    }, import("zod/v4/core").$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[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    metadata: Record<string, any> | null;
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    configId: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    referenceId: 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;
+                }>;
+                deleteApiKey: import("better-call").StrictEndpoint<"/api-key/delete", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        keyId: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").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-call").StrictEndpoint<"/api-key/list", {
+                    method: "GET";
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                            };
+                        };
+                    }>>[];
+                    query: import("zod").ZodOptional<import("zod").ZodObject<{
+                        configId: import("zod").ZodOptional<import("zod").ZodString>;
+                        organizationId: import("zod").ZodOptional<import("zod").ZodString>;
+                        limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                        offset: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                        sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+                        sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>>;
+                    }, import("zod/v4/core").$strip>>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    apiKeys: {
+                                                        type: string;
+                                                        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[];
+                                                        };
+                                                    };
+                                                    total: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    limit: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    offset: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    apiKeys: {
+                        metadata: Record<string, any> | null;
+                        permissions: {
+                            [key: string]: string[];
+                        } | null;
+                        id: string;
+                        configId: string;
+                        name: string | null;
+                        start: string | null;
+                        prefix: string | null;
+                        referenceId: 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;
+                    }[];
+                    total: number;
+                    limit: number | undefined;
+                    offset: number | undefined;
+                }>;
+                deleteAllExpiredApiKeys: import("better-call").StrictEndpoint<string, {
+                    method: "POST";
+                }, {
+                    success: boolean;
+                    error: unknown;
+                }>;
+            };
+            schema: {
+                apikey: {
+                    fields: {
+                        configId: {
+                            type: "string";
+                            required: true;
+                            defaultValue: string;
+                            input: false;
+                            index: true;
+                        };
+                        name: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        start: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        referenceId: {
+                            type: "string";
+                            required: true;
+                            input: false;
+                            index: true;
+                        };
+                        prefix: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        key: {
+                            type: "string";
+                            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").DBPrimitive): string;
+                                output(value: import("better-auth").DBPrimitive): any;
+                            };
+                        };
+                    };
+                };
+            };
+        } | {
+            id: "admin";
+            version: string;
+            init(): {
+                options: {
+                    databaseHooks: {
+                        user: {
+                            create: {
+                                before(user: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                } & Record<string, unknown>): Promise<{
+                                    data: {
+                                        id: string;
+                                        createdAt: Date;
+                                        updatedAt: Date;
+                                        email: string;
+                                        emailVerified: boolean;
+                                        name: string;
+                                        image?: string | null | undefined;
+                                        role: string;
+                                    };
+                                }>;
+                            };
+                        };
+                        session: {
+                            create: {
+                                before(session: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    userId: string;
+                                    expiresAt: Date;
+                                    token: string;
+                                    ipAddress?: string | null | undefined;
+                                    userAgent?: string | null | undefined;
+                                } & Record<string, unknown>, ctx: import("better-auth").GenericEndpointContext | null): Promise<void>;
+                            };
+                        };
+                    };
+                };
+            };
+            hooks: {
+                after: {
+                    matcher(context: import("better-auth").HookEndpointContext): boolean;
+                    handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>>;
+                }[];
+            };
+            endpoints: {
+                setRole: import("better-call").StrictEndpoint<"/admin/set-role", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        role: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
+                    }, import("zod/v4/core").$strip>;
+                    requireHeaders: true;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                userId: string;
+                                role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                getUser: import("better-call").StrictEndpoint<"/admin/get-user", {
+                    method: "GET";
+                    query: import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import("better-auth/plugins").UserWithRole>;
+                createUser: import("better-call").StrictEndpoint<"/admin/create-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        password: import("zod").ZodOptional<import("zod").ZodString>;
+                        name: import("zod").ZodString;
+                        role: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+                        data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                email: string;
+                                password?: string | undefined;
+                                name: string;
+                                role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
+                                data?: Record<string, any> | undefined;
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                adminUpdateUser: import("better-call").StrictEndpoint<"/admin/update-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        data: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, import("better-auth/plugins").UserWithRole>;
+                listUsers: import("better-call").StrictEndpoint<"/admin/list-users", {
+                    method: "GET";
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    query: import("zod").ZodObject<{
+                        searchValue: import("zod").ZodOptional<import("zod").ZodString>;
+                        searchField: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            email: "email";
+                            name: "name";
+                        }>>;
+                        searchOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            contains: "contains";
+                            starts_with: "starts_with";
+                            ends_with: "ends_with";
+                        }>>;
+                        limit: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                        offset: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                        sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+                        sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>>;
+                        filterField: import("zod").ZodOptional<import("zod").ZodString>;
+                        filterValue: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, import("zod").ZodBoolean]>, import("zod").ZodArray<import("zod").ZodString>]>, import("zod").ZodArray<import("zod").ZodNumber>]>>;
+                        filterOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            eq: "eq";
+                            ne: "ne";
+                            gt: "gt";
+                            gte: "gte";
+                            lt: "lt";
+                            lte: "lte";
+                            in: "in";
+                            not_in: "not_in";
+                            contains: "contains";
+                            starts_with: "starts_with";
+                            ends_with: "ends_with";
+                        }>>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    users: {
+                                                        type: string;
+                                                        items: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                    total: {
+                                                        type: string;
+                                                    };
+                                                    limit: {
+                                                        type: string;
+                                                    };
+                                                    offset: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    users: import("better-auth/plugins").UserWithRole[];
+                    total: number;
+                }>;
+                listUserSessions: import("better-call").StrictEndpoint<"/admin/list-user-sessions", {
+                    method: "POST";
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    sessions: {
+                                                        type: string;
+                                                        items: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
+                }>;
+                unbanUser: import("better-call").StrictEndpoint<"/admin/unban-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                banUser: import("better-call").StrictEndpoint<"/admin/ban-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                        banReason: import("zod").ZodOptional<import("zod").ZodString>;
+                        banExpiresIn: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                impersonateUser: import("better-call").StrictEndpoint<"/admin/impersonate-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    session: {
+                                                        $ref: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                stopImpersonating: import("better-call").StrictEndpoint<"/admin/stop-impersonating", {
+                    method: "POST";
+                    requireHeaders: true;
+                }, {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    } & Record<string, any>;
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    } & Record<string, any>;
+                }>;
+                revokeUserSession: import("better-call").StrictEndpoint<"/admin/revoke-user-session", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        sessionToken: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                revokeUserSessions: import("better-call").StrictEndpoint<"/admin/revoke-user-sessions", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                removeUser: import("better-call").StrictEndpoint<"/admin/remove-user", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    success: boolean;
+                }>;
+                setUserPassword: import("better-call").StrictEndpoint<"/admin/set-user-password", {
+                    method: "POST";
+                    body: import("zod").ZodObject<{
+                        newPassword: import("zod").ZodString;
+                        userId: import("zod").ZodCoercedString<unknown>;
+                    }, import("zod/v4/core").$strip>;
+                    use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                        };
+                    }>>[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    status: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    status: boolean;
+                }>;
+                userHasPermission: import("better-call").StrictEndpoint<"/admin/has-permission", {
+                    method: "POST";
+                    body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                        userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                        role: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodXor<readonly [import("zod").ZodObject<{
+                        permission: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                        permissions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                    }, import("zod/v4/core").$strip>]>>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            requestBody: {
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                permissions: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    error: {
+                                                        type: string;
+                                                    };
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                permissions: {
+                                    readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "impersonate-admins" | "set-password" | "set-email")[] | undefined;
+                                    readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                                };
+                            } & {
+                                userId?: string | undefined;
+                                role?: "user" | "admin" | "staff" | undefined;
+                            };
+                        };
+                    };
+                }, {
+                    error: null;
+                    success: boolean;
+                }>;
+            };
+            $ERROR_CODES: {
+                USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: import("better-auth").RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+                FAILED_TO_CREATE_USER: import("better-auth").RawError<"FAILED_TO_CREATE_USER">;
+                USER_ALREADY_EXISTS: import("better-auth").RawError<"USER_ALREADY_EXISTS">;
+                YOU_CANNOT_BAN_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_BAN_YOURSELF">;
+                YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+                YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+                YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+                YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+                BANNED_USER: import("better-auth").RawError<"BANNED_USER">;
+                YOU_ARE_NOT_ALLOWED_TO_GET_USER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+                NO_DATA_TO_UPDATE: import("better-auth").RawError<"NO_DATA_TO_UPDATE">;
+                YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+                YOU_CANNOT_REMOVE_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+                YOU_CANNOT_IMPERSONATE_ADMINS: import("better-auth").RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+                INVALID_ROLE_TYPE: import("better-auth").RawError<"INVALID_ROLE_TYPE">;
+                YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL">;
+                PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER: import("better-auth").RawError<"PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER">;
+            };
+            schema: {
+                user: {
+                    fields: {
+                        role: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        banned: {
+                            type: "boolean";
+                            defaultValue: false;
+                            required: false;
+                            input: false;
+                        };
+                        banReason: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                        banExpires: {
+                            type: "date";
+                            required: false;
+                            input: false;
+                        };
+                    };
+                };
+                session: {
+                    fields: {
+                        impersonatedBy: {
+                            type: "string";
+                            required: false;
+                            input: false;
+                        };
+                    };
+                };
+            };
+            options: NoInfer<{
+                accessControl: {
+                    newRole<const TRoleStatements extends import("better-auth/plugins").Statements>(statements: import("better-auth/plugins").RoleInput<{
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }, TRoleStatements>): import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<TRoleStatements>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                    statements: {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    };
+                };
+                roles: {
+                    admin: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<import("better-auth/plugins").ExactRoleStatements<{
+                        readonly user: ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: ["list", "revoke", "delete"];
+                    }>>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                    user: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<import("better-auth/plugins").ExactRoleStatements<{
+                        readonly user: [];
+                        readonly session: [];
+                    }>>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                    staff: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+                        readonly user: ["create", "list", "delete"];
+                    }>, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                    }>;
+                };
+            }>;
+        })[], ...C["$auth"] extends {
+            plugins: any;
+        } ? C["$auth"]["plugins"] : []];
+        database: unknown;
+        baseURL: any;
+        rateLimit: {
+            readonly enabled: boolean;
+            readonly window: 10;
+            readonly max: 30;
+        };
+        trustedOrigins: string[];
+        session: {
+            readonly modelName: "authSessions";
+        };
+        account: {
+            readonly modelName: "authAccounts";
+        };
+        verification: {
+            readonly modelName: "authVerifications";
+        };
+        user: {
+            readonly modelName: "authUsers";
+            readonly changeEmail: {
+                readonly enabled: true;
+            };
+            readonly deleteUser: {
+                readonly enabled: true;
+            };
+            readonly additionalFields: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly required: true;
+                };
+            };
+        };
+        hooks: {
+            readonly before: import("better-call").MiddlewareHandler;
+            readonly after: import("better-call").MiddlewareHandler;
+        };
+        emailAndPassword: {
+            readonly enabled: true;
+            readonly sendResetPassword: (data: {
+                user: any;
+                url: string;
+            }) => Promise<void>;
+        };
+    }>;
+}>;