@questpie/admin 0.0.1 → 1.0.1

package/dist/index-B9Xwk4hi.d.mts

@@ -0,0 +1,2753 @@
+import { i as ViewConfiguration } from "./saved-views.types-BMsz5mCy.mjs";
+import * as zod0 from "zod";
+import * as questpie181 from "questpie";
+import { Questpie } from "questpie";
+import * as drizzle_orm_pg_core183 from "drizzle-orm/pg-core";
+import * as drizzle_orm94 from "drizzle-orm";
+import * as better_auth0 from "better-auth";
+import * as better_call0 from "better-call";
+import * as better_auth_plugins0 from "better-auth/plugins";
+
+//#region src/server/auth-helpers.d.ts
+
+/**
+ * Session object from Better Auth
+ */
+interface AuthSession {
+  user: {
+    id: string;
+    email: string;
+    name?: string | null;
+    role?: string | null;
+    [key: string]: unknown;
+  };
+  session: {
+    id: string;
+    userId: string;
+    expiresAt: Date;
+    [key: string]: unknown;
+  };
+}
+/**
+ * Options for requireAdminAuth
+ */
+interface RequireAdminAuthOptions {
+  /**
+   * The incoming request
+   */
+  request: Request;
+  /**
+   * The CMS instance with auth configured
+   */
+  cms: Questpie<any>;
+  /**
+   * Path to redirect to when not authenticated
+   * @default "/admin/login"
+   */
+  loginPath?: string;
+  /**
+   * Required role for access
+   * @default "admin"
+   */
+  requiredRole?: string;
+  /**
+   * Query parameter name for redirect URL
+   * @default "redirect"
+   */
+  redirectParam?: string;
+}
+/**
+ * Options for getAdminSession
+ */
+interface GetAdminSessionOptions {
+  /**
+   * The incoming request
+   */
+  request: Request;
+  /**
+   * The CMS instance with auth configured
+   */
+  cms: Questpie<any>;
+}
+/**
+ * Check if user is authenticated with required role on the server.
+ * Returns a redirect Response if not authenticated, null if authenticated.
+ *
+ * Use this in server loaders/middleware to protect routes.
+ *
+ * @example TanStack Router
+ * ```ts
+ * export const Route = createFileRoute("/admin")({
+ *   beforeLoad: async ({ context }) => {
+ *     const redirect = await requireAdminAuth({
+ *       request: context.request,
+ *       cms,
+ *       loginPath: "/admin/login",
+ *     });
+ *     if (redirect) throw redirect;
+ *   },
+ * });
+ * ```
+ *
+ * @example Next.js Middleware
+ * ```ts
+ * export async function middleware(request: NextRequest) {
+ *   const redirect = await requireAdminAuth({
+ *     request,
+ *     cms,
+ *     loginPath: "/admin/login",
+ *   });
+ *   if (redirect) return redirect;
+ *   return NextResponse.next();
+ * }
+ * ```
+ */
+declare function requireAdminAuth({
+  request,
+  cms,
+  loginPath,
+  requiredRole,
+  redirectParam
+}: RequireAdminAuthOptions): Promise<Response | null>;
+/**
+ * Get the current admin session on the server.
+ * Returns null if not authenticated.
+ *
+ * Use this when you need access to the session data in server code.
+ *
+ * @example
+ * ```ts
+ * const session = await getAdminSession({ request, cms });
+ * if (!session) {
+ *   return redirect("/admin/login");
+ * }
+ * console.log("User:", session.user.name);
+ * ```
+ */
+declare function getAdminSession({
+  request,
+  cms
+}: GetAdminSessionOptions): Promise<AuthSession | null>;
+/**
+ * Check if the current user has admin role on the server.
+ *
+ * @example
+ * ```ts
+ * const isAdmin = await isAdminUser({ request, cms });
+ * if (!isAdmin) {
+ *   return json({ error: "Unauthorized" }, { status: 403 });
+ * }
+ * ```
+ */
+declare function isAdminUser({
+  request,
+  cms,
+  requiredRole
+}: GetAdminSessionOptions & {
+  requiredRole?: string;
+}): Promise<boolean>;
+//#endregion
+//#region src/server/modules/admin-preferences/collections/saved-views.collection.d.ts
+/**
+ * Admin Saved Views Collection
+ *
+ * Stores user-specific view configurations for collection lists.
+ * Each view can contain:
+ * - Filter rules (field/operator/value combinations)
+ * - Sort configuration (field/direction)
+ * - Visible columns selection
+ *
+ * @example
+ * ```ts
+ * import { adminModule } from "@questpie/admin/server";
+ *
+ * const cms = q({ name: "my-app" })
+ *   .use(starterModule)
+ *   .use(adminModule)
+ *   .collections({ ... })
+ *   .build({ ... });
+ *
+ * // Access saved views
+ * const views = await cms.api.collections.adminSavedViews.find({
+ *   where: { collectionName: "posts", userId: currentUser.id }
+ * });
+ * ```
+ */
+declare const savedViewsCollection: questpie181.CollectionBuilder<questpie181.SetProperty<questpie181.TypeMerge<questpie181.UnsetProperty<questpie181.CollectionBuilderState & {
+  name: "admin_saved_views";
+  fields: {};
+  localized: [];
+  virtuals: undefined;
+  relations: {};
+  indexes: {};
+  title: undefined;
+  options: {};
+  hooks: questpie181.CollectionHooks<any, any, any>;
+  access: {};
+  functions: {};
+  searchable: undefined;
+  validation: undefined;
+  output: undefined;
+  upload: undefined;
+}, "localized" | "fields">, {
+  fields: {
+    userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+    collectionName: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+    name: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+    configuration: drizzle_orm94.$Type<drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgJsonbBuilder>, ViewConfiguration>;
+    isDefault: drizzle_orm94.NotNull<drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgBooleanBuilder>>;
+  };
+  localized: [];
+}>, "options", {
+  timestamps: true;
+}>>;
+//#endregion
+//#region src/server/modules/admin/functions/preview.d.ts
+/**
+ * Preview Functions - Server-side
+ *
+ * RPC functions for draft mode preview.
+ * Handles token minting for secure, shareable preview links.
+ *
+ * Browser-safe utilities (isDraftMode, createDraftModeCookie, etc.) are in @questpie/admin/shared
+ */
+interface PreviewTokenPayload {
+  path: string;
+  exp: number;
+}
+/**
+ * Create preview-related RPC functions.
+ *
+ * @param secret - Secret key for signing tokens
+ * @returns Object with preview functions
+ */
+declare function createPreviewFunctions(secret: string): {
+  mintPreviewToken: questpie181.JsonFunctionDefinition<{
+    path: string;
+    ttlMs?: number | undefined;
+  }, {
+    token: string;
+    expiresAt: number;
+  }, any>;
+  verifyPreviewToken: questpie181.JsonFunctionDefinition<{
+    token: string;
+  }, {
+    valid: boolean;
+    path?: string | undefined;
+    error?: string | undefined;
+  }, any>;
+};
+/**
+ * Verify a preview token without RPC.
+ * Used directly in route handlers where RPC is not available.
+ *
+ * @param token - The preview token to verify
+ * @param secret - The secret used to sign the token
+ * @returns The payload if valid, null otherwise
+ */
+declare function verifyPreviewTokenDirect(token: string, secret: string): PreviewTokenPayload | null;
+/**
+ * Create a preview token verifier with bound secret.
+ * Use this in route handlers to avoid passing secret repeatedly.
+ *
+ * @param secret - The secret used to sign tokens (optional, uses env if not provided)
+ * @returns A verify function that only needs the token
+ *
+ * @example
+ * ```ts
+ * // Create once at module level
+ * const verifyPreviewToken = createPreviewTokenVerifier();
+ *
+ * // Use in route handler
+ * const payload = verifyPreviewToken(token);
+ * if (!payload) {
+ *   return new Response("Invalid token", { status: 401 });
+ * }
+ * ```
+ */
+declare function createPreviewTokenVerifier(secret?: string): (token: string) => PreviewTokenPayload | null;
+//#endregion
+//#region src/server/modules/admin/functions/setup.d.ts
+/**
+ * Setup Functions
+ *
+ * Built-in functions for bootstrapping the first admin user.
+ * Solves the chicken-and-egg problem where invitation-based systems
+ * need an existing admin to create the first invitation.
+ */
+/**
+ * Check if setup is required (no users exist in the system).
+ *
+ * @example
+ * ```ts
+ * const result = await client.rpc.isSetupRequired({});
+ * if (result.required) {
+ *   // Redirect to setup page
+ * }
+ * ```
+ */
+declare const isSetupRequired: questpie181.JsonFunctionDefinition<Record<string, never>, {
+  required: boolean;
+}, any>;
+/**
+ * Create the first admin user in the system.
+ * This function only works when no users exist (setup mode).
+ *
+ * Security: Once any user exists, this function will refuse to create more users.
+ * This prevents unauthorized admin creation after initial setup.
+ *
+ * @example
+ * ```ts
+ * const result = await client.rpc.createFirstAdmin({
+ *   email: "admin@example.com",
+ *   password: "securepassword123",
+ *   name: "Admin User",
+ * });
+ *
+ * if (result.success) {
+ *   // Redirect to login page
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare const createFirstAdmin: questpie181.JsonFunctionDefinition<{
+  email: string;
+  password: string;
+  name: string;
+}, {
+  success: boolean;
+  user?: {
+    id: string;
+    email: string;
+    name: string;
+  } | undefined;
+  error?: string | undefined;
+}, any>;
+/**
+ * Bundle of setup-related functions.
+ */
+declare const setupFunctions: {
+  readonly isSetupRequired: questpie181.JsonFunctionDefinition<Record<string, never>, {
+    required: boolean;
+  }, any>;
+  readonly createFirstAdmin: questpie181.JsonFunctionDefinition<{
+    email: string;
+    password: string;
+    name: string;
+  }, {
+    success: boolean;
+    user?: {
+      id: string;
+      email: string;
+      name: string;
+    } | undefined;
+    error?: string | undefined;
+  }, any>;
+};
+//#endregion
+//#region src/server/modules/admin/index.d.ts
+/**
+ * Admin Module - the complete backend for QuestPie admin panel.
+ *
+ * This module provides everything needed to run the admin panel:
+ * - User authentication (Better Auth) - from starterModule
+ * - File uploads (assets) - from starterModule
+ * - Saved views for collection filters (named configurations)
+ * - User preferences (view state synced across devices)
+ * - Setup flow for first admin creation
+ *
+ * @example
+ * ```ts
+ * import { q } from "questpie";
+ * import { adminModule } from "@questpie/admin/server";
+ *
+ * const cms = q({ name: "my-app" })
+ *   .use(adminModule)
+ *   .collections({
+ *     posts: postsCollection,
+ *   })
+ *   .build({
+ *     db: { url: process.env.DATABASE_URL },
+ *   });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Extend assets collection with custom fields
+ * import { q, collection, varchar } from "questpie";
+ * import { adminModule } from "@questpie/admin/server";
+ *
+ * const cms = q({ name: "my-app" })
+ *   .use(adminModule)
+ *   .collections({
+ *     // Override assets with additional fields
+ *     assets: adminModule.state.collections.assets.merge(
+ *       collection("assets").fields({
+ *         folder: varchar("folder", { length: 255 }),
+ *         tags: varchar("tags", { length: 1000 }),
+ *       })
+ *     ),
+ *   })
+ *   .build({ ... });
+ * ```
+ */
+declare const adminModule: questpie181.QuestpieBuilder<questpie181.SetProperty<questpie181.SetProperty<{
+  name: "questpie-admin";
+  collections: questpie181.TypeMerge<questpie181.UnsetProperty<{}, keyof TOtherCollections>, {
+    assets: questpie181.CollectionBuilder<{
+      options: {
+        timestamps: true;
+      };
+      name: "assets";
+      fields: {
+        width: drizzle_orm_pg_core183.PgIntegerBuilder;
+        height: drizzle_orm_pg_core183.PgIntegerBuilder;
+        alt: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        caption: drizzle_orm_pg_core183.PgTextBuilder<[string, ...string[]]>;
+      } & {
+        key: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        filename: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        mimeType: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        size: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgIntegerBuilder>;
+        visibility: drizzle_orm94.HasDefault<drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<["public", "private"]>>>;
+      };
+      localized: [];
+      virtuals: undefined;
+      relations: Record<string, questpie181.RelationConfig>;
+      indexes: Record<string, any>;
+      title: "filename";
+      hooks: {
+        afterDelete: ({
+          data,
+          app
+        }: questpie181.HookContext<{
+          width: number | null;
+          height: number | null;
+          alt: string | null;
+          caption: string | null;
+          visibility: "public" | "private";
+          id: string;
+          key: string;
+          filename: string;
+          size: number;
+          mimeType: string;
+          createdAt: Date;
+          updatedAt: Date;
+          _title: string;
+          url: string;
+        }, never, "delete", any>) => Promise<void>;
+      };
+      access: questpie181.CollectionAccess<any, any>;
+      functions: {
+        [x: string]: questpie181.FunctionDefinition<any, any, any>;
+      };
+      searchable: undefined;
+      validation: undefined;
+      output: questpie181.TypeMerge<{}, {
+        url: string;
+      }>;
+      upload: questpie181.UploadOptions;
+    }>;
+    user: questpie181.CollectionBuilder<{
+      options: {
+        timestamps: true;
+      };
+      name: "user";
+      fields: {
+        name: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        email: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        emailVerified: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgBooleanBuilder>;
+        image: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        role: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        banned: drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgBooleanBuilder>;
+        banReason: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        banExpires: drizzle_orm_pg_core183.PgTimestampBuilder;
+      };
+      localized: [];
+      virtuals: undefined;
+      relations: Record<string, questpie181.RelationConfig>;
+      indexes: Record<string, any>;
+      title: "name";
+      hooks: questpie181.CollectionHooks<any, any, any, any>;
+      access: questpie181.CollectionAccess<any, any>;
+      functions: {
+        [x: string]: questpie181.FunctionDefinition<any, any, any>;
+      };
+      searchable: undefined;
+      validation: undefined;
+      output: undefined;
+      upload: undefined;
+    }>;
+    session: questpie181.CollectionBuilder<{
+      options: questpie181.CollectionOptions;
+      name: "session";
+      fields: {
+        userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        token: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        expiresAt: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgTimestampBuilder>;
+        ipAddress: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        userAgent: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        impersonatedBy: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      };
+      localized: [];
+      virtuals: undefined;
+      relations: Record<string, questpie181.RelationConfig>;
+      indexes: Record<string, any>;
+      title: "token";
+      hooks: questpie181.CollectionHooks<any, any, any, any>;
+      access: questpie181.CollectionAccess<any, any>;
+      functions: {
+        [x: string]: questpie181.FunctionDefinition<any, any, any>;
+      };
+      searchable: undefined;
+      validation: undefined;
+      output: undefined;
+      upload: undefined;
+    }>;
+    account: questpie181.CollectionBuilder<{
+      options: questpie181.CollectionOptions;
+      name: "account";
+      fields: {
+        userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        accountId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        providerId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        accessToken: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        refreshToken: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        accessTokenExpiresAt: drizzle_orm_pg_core183.PgTimestampBuilder;
+        refreshTokenExpiresAt: drizzle_orm_pg_core183.PgTimestampBuilder;
+        scope: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        idToken: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        password: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      };
+      localized: [];
+      virtuals: undefined;
+      relations: Record<string, questpie181.RelationConfig>;
+      indexes: Record<string, any>;
+      title: "providerId";
+      hooks: questpie181.CollectionHooks<any, any, any, any>;
+      access: questpie181.CollectionAccess<any, any>;
+      functions: {
+        [x: string]: questpie181.FunctionDefinition<any, any, any>;
+      };
+      searchable: undefined;
+      validation: undefined;
+      output: undefined;
+      upload: undefined;
+    }>;
+    verification: questpie181.CollectionBuilder<{
+      options: questpie181.CollectionOptions;
+      name: "verification";
+      fields: {
+        identifier: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        value: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        expiresAt: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgTimestampBuilder>;
+      };
+      localized: [];
+      virtuals: undefined;
+      relations: Record<string, questpie181.RelationConfig>;
+      indexes: Record<string, any>;
+      title: "identifier";
+      hooks: questpie181.CollectionHooks<any, any, any, any>;
+      access: questpie181.CollectionAccess<any, any>;
+      functions: {
+        [x: string]: questpie181.FunctionDefinition<any, any, any>;
+      };
+      searchable: undefined;
+      validation: undefined;
+      output: undefined;
+      upload: undefined;
+    }>;
+    apikey: questpie181.CollectionBuilder<{
+      options: {
+        timestamps: true;
+      };
+      name: "apikey";
+      fields: {
+        name: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        start: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        prefix: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+        key: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+        refillInterval: drizzle_orm_pg_core183.PgIntegerBuilder;
+        refillAmount: drizzle_orm_pg_core183.PgIntegerBuilder;
+        lastRefillAt: drizzle_orm_pg_core183.PgTimestampBuilder;
+        enabled: drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgBooleanBuilder>;
+        rateLimitEnabled: drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgBooleanBuilder>;
+        rateLimitTimeWindow: drizzle_orm_pg_core183.PgIntegerBuilder;
+        rateLimitMax: drizzle_orm_pg_core183.PgIntegerBuilder;
+        requestCount: drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgIntegerBuilder>;
+        remaining: drizzle_orm_pg_core183.PgIntegerBuilder;
+        lastRequest: drizzle_orm_pg_core183.PgTimestampBuilder;
+        expiresAt: drizzle_orm_pg_core183.PgTimestampBuilder;
+        permissions: drizzle_orm_pg_core183.PgTextBuilder<[string, ...string[]]>;
+        metadata: drizzle_orm_pg_core183.PgTextBuilder<[string, ...string[]]>;
+      };
+      localized: [];
+      virtuals: undefined;
+      relations: Record<string, questpie181.RelationConfig>;
+      indexes: Record<string, any>;
+      title: "key";
+      hooks: questpie181.CollectionHooks<any, any, any, any>;
+      access: questpie181.CollectionAccess<any, any>;
+      functions: {
+        [x: string]: questpie181.FunctionDefinition<any, any, any>;
+      };
+      searchable: undefined;
+      validation: undefined;
+      output: undefined;
+      upload: undefined;
+    }>;
+  }>;
+  globals: questpie181.TypeMerge<questpie181.UnsetProperty<{}, keyof TOtherGlobals>, {}>;
+  jobs: questpie181.TypeMerge<questpie181.UnsetProperty<{}, keyof TOtherJobs>, {}>;
+  emailTemplates: questpie181.TypeMerge<questpie181.UnsetProperty<{}, keyof TOtherEmailTemplates>, {}>;
+  functions: questpie181.TypeMerge<questpie181.UnsetProperty<{}, keyof TOtherFunctions>, {}>;
+  auth: questpie181.MergeAuthOptions<{}, questpie181.MergeAuthOptions<{}, {
+    baseURL: string | undefined;
+    secret: string | undefined;
+    advanced: {
+      useSecureCookies: boolean;
+    };
+    plugins: [{
+      id: "admin";
+      init(): {
+        options: {
+          databaseHooks: {
+            user: {
+              create: {
+                before(user: {
+                  id: string;
+                  createdAt: Date;
+                  updatedAt: Date;
+                  email: string;
+                  emailVerified: boolean;
+                  name: string;
+                  image?: string | null | undefined;
+                } & Record<string, unknown>): Promise<{
+                  data: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                    role: string;
+                  };
+                }>;
+              };
+            };
+            session: {
+              create: {
+                before(session: {
+                  id: string;
+                  createdAt: Date;
+                  updatedAt: Date;
+                  userId: string;
+                  expiresAt: Date;
+                  token: string;
+                  ipAddress?: string | null | undefined;
+                  userAgent?: string | null | undefined;
+                } & Record<string, unknown>, ctx: better_auth0.GenericEndpointContext | null): Promise<void>;
+              };
+            };
+          };
+        };
+      };
+      hooks: {
+        after: {
+          matcher(context: better_auth0.HookEndpointContext): boolean;
+          handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<better_auth_plugins0.SessionWithImpersonatedBy[] | undefined>;
+        }[];
+      };
+      endpoints: {
+        setRole: better_call0.StrictEndpoint<"/admin/set-role", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            userId: zod0.ZodCoercedString<unknown>;
+            role: zod0.ZodUnion<readonly [zod0.ZodString, zod0.ZodArray<zod0.ZodString>]>;
+          }, better_auth0.$strip>;
+          requireHeaders: true;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+            $Infer: {
+              body: {
+                userId: string;
+                role: "user" | "admin" | ("user" | "admin")[];
+              };
+            };
+          };
+        }, {
+          user: better_auth_plugins0.UserWithRole;
+        }>;
+        getUser: better_call0.StrictEndpoint<"/admin/get-user", {
+          method: "GET";
+          query: zod0.ZodObject<{
+            id: zod0.ZodString;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, better_auth_plugins0.UserWithRole>;
+        createUser: better_call0.StrictEndpoint<"/admin/create-user", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            email: zod0.ZodString;
+            password: zod0.ZodOptional<zod0.ZodString>;
+            name: zod0.ZodString;
+            role: zod0.ZodOptional<zod0.ZodUnion<readonly [zod0.ZodString, zod0.ZodArray<zod0.ZodString>]>>;
+            data: zod0.ZodOptional<zod0.ZodRecord<zod0.ZodString, zod0.ZodAny>>;
+          }, better_auth0.$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" | ("user" | "admin")[] | undefined;
+                data?: Record<string, any> | undefined;
+              };
+            };
+          };
+        }, {
+          user: better_auth_plugins0.UserWithRole;
+        }>;
+        adminUpdateUser: better_call0.StrictEndpoint<"/admin/update-user", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            userId: zod0.ZodCoercedString<unknown>;
+            data: zod0.ZodRecord<zod0.ZodAny, zod0.ZodAny>;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, better_auth_plugins0.UserWithRole>;
+        listUsers: better_call0.StrictEndpoint<"/admin/list-users", {
+          method: "GET";
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          query: zod0.ZodObject<{
+            searchValue: zod0.ZodOptional<zod0.ZodString>;
+            searchField: zod0.ZodOptional<zod0.ZodEnum<{
+              name: "name";
+              email: "email";
+            }>>;
+            searchOperator: zod0.ZodOptional<zod0.ZodEnum<{
+              contains: "contains";
+              starts_with: "starts_with";
+              ends_with: "ends_with";
+            }>>;
+            limit: zod0.ZodOptional<zod0.ZodUnion<[zod0.ZodString, zod0.ZodNumber]>>;
+            offset: zod0.ZodOptional<zod0.ZodUnion<[zod0.ZodString, zod0.ZodNumber]>>;
+            sortBy: zod0.ZodOptional<zod0.ZodString>;
+            sortDirection: zod0.ZodOptional<zod0.ZodEnum<{
+              asc: "asc";
+              desc: "desc";
+            }>>;
+            filterField: zod0.ZodOptional<zod0.ZodString>;
+            filterValue: zod0.ZodOptional<zod0.ZodUnion<[zod0.ZodUnion<[zod0.ZodString, zod0.ZodNumber]>, zod0.ZodBoolean]>>;
+            filterOperator: zod0.ZodOptional<zod0.ZodEnum<{
+              eq: "eq";
+              ne: "ne";
+              lt: "lt";
+              lte: "lte";
+              gt: "gt";
+              gte: "gte";
+              contains: "contains";
+            }>>;
+          }, better_auth0.$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: better_auth_plugins0.UserWithRole[];
+          total: number;
+          limit: number | undefined;
+          offset: number | undefined;
+        } | {
+          users: never[];
+          total: number;
+        }>;
+        listUserSessions: better_call0.StrictEndpoint<"/admin/list-user-sessions", {
+          method: "POST";
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          body: zod0.ZodObject<{
+            userId: zod0.ZodCoercedString<unknown>;
+          }, better_auth0.$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: better_auth_plugins0.SessionWithImpersonatedBy[];
+        }>;
+        unbanUser: better_call0.StrictEndpoint<"/admin/unban-user", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            userId: zod0.ZodCoercedString<unknown>;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          user: better_auth_plugins0.UserWithRole;
+        }>;
+        banUser: better_call0.StrictEndpoint<"/admin/ban-user", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            userId: zod0.ZodCoercedString<unknown>;
+            banReason: zod0.ZodOptional<zod0.ZodString>;
+            banExpiresIn: zod0.ZodOptional<zod0.ZodNumber>;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          user: better_auth_plugins0.UserWithRole;
+        }>;
+        impersonateUser: better_call0.StrictEndpoint<"/admin/impersonate-user", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            userId: zod0.ZodCoercedString<unknown>;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          session: {
+                            $ref: string;
+                          };
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          session: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+          };
+          user: better_auth_plugins0.UserWithRole;
+        }>;
+        stopImpersonating: better_call0.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: better_call0.StrictEndpoint<"/admin/revoke-user-session", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            sessionToken: zod0.ZodString;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        revokeUserSessions: better_call0.StrictEndpoint<"/admin/revoke-user-sessions", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            userId: zod0.ZodCoercedString<unknown>;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        removeUser: better_call0.StrictEndpoint<"/admin/remove-user", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            userId: zod0.ZodCoercedString<unknown>;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        setUserPassword: better_call0.StrictEndpoint<"/admin/set-user-password", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            newPassword: zod0.ZodString;
+            userId: zod0.ZodCoercedString<unknown>;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              user: better_auth_plugins0.UserWithRole;
+              session: better_auth0.Session;
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              summary: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          status: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          status: boolean;
+        }>;
+        userHasPermission: better_call0.StrictEndpoint<"/admin/has-permission", {
+          method: "POST";
+          body: zod0.ZodIntersection<zod0.ZodObject<{
+            userId: zod0.ZodOptional<zod0.ZodCoercedString<unknown>>;
+            role: zod0.ZodOptional<zod0.ZodString>;
+          }, better_auth0.$strip>, zod0.ZodUnion<readonly [zod0.ZodObject<{
+            permission: zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>;
+            permissions: zod0.ZodUndefined;
+          }, better_auth0.$strip>, zod0.ZodObject<{
+            permission: zod0.ZodUndefined;
+            permissions: zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>;
+          }, better_auth0.$strip>]>>;
+          metadata: {
+            openapi: {
+              description: string;
+              requestBody: {
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        permission: {
+                          type: string;
+                          description: string;
+                          deprecated: boolean;
+                        };
+                        permissions: {
+                          type: string;
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+              responses: {
+                "200": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          error: {
+                            type: string;
+                          };
+                          success: {
+                            type: string;
+                          };
+                        };
+                        required: string[];
+                      };
+                    };
+                  };
+                };
+              };
+            };
+            $Infer: {
+              body: ({
+                permission: {
+                  readonly user?: ("delete" | "set-role" | "create" | "get" | "update" | "list" | "ban" | "impersonate" | "set-password")[] | undefined;
+                  readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                };
+                permissions?: never | undefined;
+              } | {
+                permissions: {
+                  readonly user?: ("delete" | "set-role" | "create" | "get" | "update" | "list" | "ban" | "impersonate" | "set-password")[] | undefined;
+                  readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                };
+                permission?: never | undefined;
+              }) & {
+                userId?: string | undefined;
+                role?: "user" | "admin" | undefined;
+              };
+            };
+          };
+        }, {
+          error: null;
+          success: boolean;
+        }>;
+      };
+      $ERROR_CODES: {
+        readonly FAILED_TO_CREATE_USER: "Failed to create user";
+        readonly USER_ALREADY_EXISTS: "User already exists.";
+        readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+        readonly YOU_CANNOT_BAN_YOURSELF: "You cannot ban yourself";
+        readonly YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: "You are not allowed to change users role";
+        readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: "You are not allowed to create users";
+        readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: "You are not allowed to list users";
+        readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: "You are not allowed to list users sessions";
+        readonly YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: "You are not allowed to ban users";
+        readonly YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: "You are not allowed to impersonate users";
+        readonly YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: "You are not allowed to revoke users sessions";
+        readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: "You are not allowed to delete users";
+        readonly YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: "You are not allowed to set users password";
+        readonly BANNED_USER: "You have been banned from this application";
+        readonly YOU_ARE_NOT_ALLOWED_TO_GET_USER: "You are not allowed to get user";
+        readonly NO_DATA_TO_UPDATE: "No data to update";
+        readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: "You are not allowed to update users";
+        readonly YOU_CANNOT_REMOVE_YOURSELF: "You cannot remove yourself";
+        readonly YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: "You are not allowed to set a non-existent role value";
+        readonly YOU_CANNOT_IMPERSONATE_ADMINS: "You cannot impersonate admins";
+        readonly INVALID_ROLE_TYPE: "Invalid role type";
+      };
+      schema: {
+        user: {
+          fields: {
+            role: {
+              type: "string";
+              required: false;
+              input: false;
+            };
+            banned: {
+              type: "boolean";
+              defaultValue: false;
+              required: false;
+              input: false;
+            };
+            banReason: {
+              type: "string";
+              required: false;
+              input: false;
+            };
+            banExpires: {
+              type: "date";
+              required: false;
+              input: false;
+            };
+          };
+        };
+        session: {
+          fields: {
+            impersonatedBy: {
+              type: "string";
+              required: false;
+            };
+          };
+        };
+      };
+      options: NoInfer<better_auth_plugins0.AdminOptions>;
+    }, {
+      id: "api-key";
+      $ERROR_CODES: {
+        readonly INVALID_METADATA_TYPE: "metadata must be an object or undefined";
+        readonly REFILL_AMOUNT_AND_INTERVAL_REQUIRED: "refillAmount is required when refillInterval is provided";
+        readonly REFILL_INTERVAL_AND_AMOUNT_REQUIRED: "refillInterval is required when refillAmount is provided";
+        readonly USER_BANNED: "User is banned";
+        readonly UNAUTHORIZED_SESSION: "Unauthorized or invalid session";
+        readonly KEY_NOT_FOUND: "API Key not found";
+        readonly KEY_DISABLED: "API Key is disabled";
+        readonly KEY_EXPIRED: "API Key has expired";
+        readonly USAGE_EXCEEDED: "API Key has reached its usage limit";
+        readonly KEY_NOT_RECOVERABLE: "API Key is not recoverable";
+        readonly EXPIRES_IN_IS_TOO_SMALL: "The expiresIn is smaller than the predefined minimum value.";
+        readonly EXPIRES_IN_IS_TOO_LARGE: "The expiresIn is larger than the predefined maximum value.";
+        readonly INVALID_REMAINING: "The remaining count is either too large or too small.";
+        readonly INVALID_PREFIX_LENGTH: "The prefix length is either too large or too small.";
+        readonly INVALID_NAME_LENGTH: "The name length is either too large or too small.";
+        readonly METADATA_DISABLED: "Metadata is disabled.";
+        readonly RATE_LIMIT_EXCEEDED: "Rate limit exceeded.";
+        readonly NO_VALUES_TO_UPDATE: "No values to update.";
+        readonly KEY_DISABLED_EXPIRATION: "Custom key expiration values are disabled.";
+        readonly INVALID_API_KEY: "Invalid API key.";
+        readonly INVALID_USER_ID_FROM_API_KEY: "The user id from the API key is invalid.";
+        readonly INVALID_API_KEY_GETTER_RETURN_TYPE: "API Key getter returned an invalid key type. Expected string.";
+        readonly SERVER_ONLY_PROPERTY: "The property you're trying to set can only be set from the server auth instance only.";
+        readonly FAILED_TO_UPDATE_API_KEY: "Failed to update API key";
+        readonly NAME_REQUIRED: "API Key name is required.";
+      };
+      hooks: {
+        before: {
+          matcher: (ctx: better_auth0.HookEndpointContext) => boolean;
+          handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.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: better_call0.MiddlewareContext<better_call0.MiddlewareOptions, {
+              returned?: unknown | undefined;
+              responseHeaders?: Headers | undefined;
+            } & better_auth0.PluginContext & better_auth0.InfoContext & {
+              options: better_auth0.BetterAuthOptions;
+              trustedOrigins: string[];
+              isTrustedOrigin: (url: string, settings?: {
+                allowRelativePaths: boolean;
+              }) => boolean;
+              oauthConfig: {
+                skipStateCookieCheck?: boolean | undefined;
+                storeStateStrategy: "database" | "cookie";
+              };
+              newSession: {
+                session: better_auth0.Session & Record<string, any>;
+                user: better_auth0.User & Record<string, any>;
+              } | null;
+              session: {
+                session: better_auth0.Session & Record<string, any>;
+                user: better_auth0.User & Record<string, any>;
+              } | null;
+              setNewSession: (session: {
+                session: better_auth0.Session & Record<string, any>;
+                user: better_auth0.User & Record<string, any>;
+              } | null) => void;
+              socialProviders: better_auth0.OAuthProvider[];
+              authCookies: better_auth0.BetterAuthCookies;
+              logger: ReturnType<(options?: better_auth0.Logger | undefined) => better_auth0.InternalLogger>;
+              rateLimit: {
+                enabled: boolean;
+                window: number;
+                max: number;
+                storage: "memory" | "database" | "secondary-storage";
+              } & Omit<better_auth0.BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+              adapter: better_auth0.DBAdapter<better_auth0.BetterAuthOptions>;
+              internalAdapter: better_auth0.InternalAdapter<better_auth0.BetterAuthOptions>;
+              createAuthCookie: (cookieName: string, overrideAttributes?: Partial<better_call0.CookieOptions> | undefined) => better_auth0.BetterAuthCookie;
+              secret: string;
+              sessionConfig: {
+                updateAge: number;
+                expiresIn: number;
+                freshAge: number;
+                cookieRefreshCache: false | {
+                  enabled: true;
+                  updateAge: number;
+                };
+              };
+              generateId: (options: {
+                model: better_auth0.ModelNames;
+                size?: number | undefined;
+              }) => string | false;
+              secondaryStorage: better_auth0.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: better_auth0.GenericEndpointContext<better_auth0.BetterAuthOptions>) => Promise<boolean>;
+              };
+              tables: better_auth0.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<void>) => void;
+              runInBackgroundOrAwait: (promise: Promise<unknown> | Promise<void> | void | unknown) => Promise<unknown>;
+            }>;
+          }>;
+        }[];
+      };
+      endpoints: {
+        createApiKey: better_call0.StrictEndpoint<"/api-key/create", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            name: zod0.ZodOptional<zod0.ZodString>;
+            expiresIn: zod0.ZodDefault<zod0.ZodNullable<zod0.ZodOptional<zod0.ZodNumber>>>;
+            userId: zod0.ZodOptional<zod0.ZodCoercedString<unknown>>;
+            prefix: zod0.ZodOptional<zod0.ZodString>;
+            remaining: zod0.ZodDefault<zod0.ZodNullable<zod0.ZodOptional<zod0.ZodNumber>>>;
+            metadata: zod0.ZodOptional<zod0.ZodAny>;
+            refillAmount: zod0.ZodOptional<zod0.ZodNumber>;
+            refillInterval: zod0.ZodOptional<zod0.ZodNumber>;
+            rateLimitTimeWindow: zod0.ZodOptional<zod0.ZodNumber>;
+            rateLimitMax: zod0.ZodOptional<zod0.ZodNumber>;
+            rateLimitEnabled: zod0.ZodOptional<zod0.ZodBoolean>;
+            permissions: zod0.ZodOptional<zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>>;
+          }, better_auth0.$strip>;
+          metadata: {
+            openapi: {
+              description: string;
+              responses: {
+                "200": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          id: {
+                            type: string;
+                            description: string;
+                          };
+                          createdAt: {
+                            type: string;
+                            format: string;
+                            description: string;
+                          };
+                          updatedAt: {
+                            type: string;
+                            format: string;
+                            description: string;
+                          };
+                          name: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          prefix: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          start: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          key: {
+                            type: string;
+                            description: string;
+                          };
+                          enabled: {
+                            type: string;
+                            description: string;
+                          };
+                          expiresAt: {
+                            type: string;
+                            format: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          userId: {
+                            type: string;
+                            description: string;
+                          };
+                          lastRefillAt: {
+                            type: string;
+                            format: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          lastRequest: {
+                            type: string;
+                            format: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          metadata: {
+                            type: string;
+                            nullable: boolean;
+                            additionalProperties: boolean;
+                            description: string;
+                          };
+                          rateLimitMax: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          rateLimitTimeWindow: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          remaining: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          refillAmount: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          refillInterval: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          rateLimitEnabled: {
+                            type: string;
+                            description: string;
+                          };
+                          requestCount: {
+                            type: string;
+                            description: string;
+                          };
+                          permissions: {
+                            type: string;
+                            nullable: boolean;
+                            additionalProperties: {
+                              type: string;
+                              items: {
+                                type: string;
+                              };
+                            };
+                            description: string;
+                          };
+                        };
+                        required: string[];
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          key: string;
+          metadata: any;
+          permissions: any;
+          id: string;
+          name: string | null;
+          start: string | null;
+          prefix: string | null;
+          userId: string;
+          refillInterval: number | null;
+          refillAmount: number | null;
+          lastRefillAt: Date | null;
+          enabled: boolean;
+          rateLimitEnabled: boolean;
+          rateLimitTimeWindow: number | null;
+          rateLimitMax: number | null;
+          requestCount: number;
+          remaining: number | null;
+          lastRequest: Date | null;
+          expiresAt: Date | null;
+          createdAt: Date;
+          updatedAt: Date;
+        }>;
+        verifyApiKey: better_call0.StrictEndpoint<string, {
+          method: "POST";
+          body: zod0.ZodObject<{
+            key: zod0.ZodString;
+            permissions: zod0.ZodOptional<zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>>;
+          }, better_auth0.$strip>;
+        }, {
+          valid: boolean;
+          error: {
+            message: string | undefined;
+            code: string;
+          };
+          key: null;
+        } | {
+          valid: boolean;
+          error: null;
+          key: Omit<better_auth_plugins0.ApiKey, "key"> | null;
+        }>;
+        getApiKey: better_call0.StrictEndpoint<"/api-key/get", {
+          method: "GET";
+          query: zod0.ZodObject<{
+            id: zod0.ZodString;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.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;
+          name: string | null;
+          start: string | null;
+          prefix: string | null;
+          userId: string;
+          refillInterval: number | null;
+          refillAmount: number | null;
+          lastRefillAt: Date | null;
+          enabled: boolean;
+          rateLimitEnabled: boolean;
+          rateLimitTimeWindow: number | null;
+          rateLimitMax: number | null;
+          requestCount: number;
+          remaining: number | null;
+          lastRequest: Date | null;
+          expiresAt: Date | null;
+          createdAt: Date;
+          updatedAt: Date;
+        }>;
+        updateApiKey: better_call0.StrictEndpoint<"/api-key/update", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            keyId: zod0.ZodString;
+            userId: zod0.ZodOptional<zod0.ZodCoercedString<unknown>>;
+            name: zod0.ZodOptional<zod0.ZodString>;
+            enabled: zod0.ZodOptional<zod0.ZodBoolean>;
+            remaining: zod0.ZodOptional<zod0.ZodNumber>;
+            refillAmount: zod0.ZodOptional<zod0.ZodNumber>;
+            refillInterval: zod0.ZodOptional<zod0.ZodNumber>;
+            metadata: zod0.ZodOptional<zod0.ZodAny>;
+            expiresIn: zod0.ZodNullable<zod0.ZodOptional<zod0.ZodNumber>>;
+            rateLimitEnabled: zod0.ZodOptional<zod0.ZodBoolean>;
+            rateLimitTimeWindow: zod0.ZodOptional<zod0.ZodNumber>;
+            rateLimitMax: zod0.ZodOptional<zod0.ZodNumber>;
+            permissions: zod0.ZodNullable<zod0.ZodOptional<zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>>>;
+          }, better_auth0.$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;
+          name: string | null;
+          start: string | null;
+          prefix: string | null;
+          userId: string;
+          refillInterval: number | null;
+          refillAmount: number | null;
+          lastRefillAt: Date | null;
+          enabled: boolean;
+          rateLimitEnabled: boolean;
+          rateLimitTimeWindow: number | null;
+          rateLimitMax: number | null;
+          requestCount: number;
+          remaining: number | null;
+          lastRequest: Date | null;
+          expiresAt: Date | null;
+          createdAt: Date;
+          updatedAt: Date;
+        }>;
+        deleteApiKey: better_call0.StrictEndpoint<"/api-key/delete", {
+          method: "POST";
+          body: zod0.ZodObject<{
+            keyId: zod0.ZodString;
+          }, better_auth0.$strip>;
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.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: better_call0.StrictEndpoint<"/api-key/list", {
+          method: "GET";
+          use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>)[];
+          metadata: {
+            openapi: {
+              description: string;
+              responses: {
+                "200": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "array";
+                        items: {
+                          type: string;
+                          properties: {
+                            id: {
+                              type: string;
+                              description: string;
+                            };
+                            name: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            start: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            prefix: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            userId: {
+                              type: string;
+                              description: string;
+                            };
+                            refillInterval: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            refillAmount: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            lastRefillAt: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            enabled: {
+                              type: string;
+                              description: string;
+                              default: boolean;
+                            };
+                            rateLimitEnabled: {
+                              type: string;
+                              description: string;
+                            };
+                            rateLimitTimeWindow: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            rateLimitMax: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            requestCount: {
+                              type: string;
+                              description: string;
+                            };
+                            remaining: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            lastRequest: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            expiresAt: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            createdAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            updatedAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            metadata: {
+                              type: string;
+                              nullable: boolean;
+                              additionalProperties: boolean;
+                              description: string;
+                            };
+                            permissions: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          metadata: Record<string, any> | null;
+          permissions: {
+            [key: string]: string[];
+          } | null;
+          id: string;
+          name: string | null;
+          start: string | null;
+          prefix: string | null;
+          userId: string;
+          refillInterval: number | null;
+          refillAmount: number | null;
+          lastRefillAt: Date | null;
+          enabled: boolean;
+          rateLimitEnabled: boolean;
+          rateLimitTimeWindow: number | null;
+          rateLimitMax: number | null;
+          requestCount: number;
+          remaining: number | null;
+          lastRequest: Date | null;
+          expiresAt: Date | null;
+          createdAt: Date;
+          updatedAt: Date;
+        }[]>;
+        deleteAllExpiredApiKeys: better_call0.StrictEndpoint<string, {
+          method: "POST";
+        }, {
+          success: boolean;
+          error: unknown;
+        }>;
+      };
+      schema: {
+        apikey: {
+          fields: {
+            name: {
+              type: "string";
+              required: false;
+              input: false;
+            };
+            start: {
+              type: "string";
+              required: false;
+              input: false;
+            };
+            prefix: {
+              type: "string";
+              required: false;
+              input: false;
+            };
+            key: {
+              type: "string";
+              required: true;
+              input: false;
+              index: true;
+            };
+            userId: {
+              type: "string";
+              references: {
+                model: string;
+                field: string;
+                onDelete: "cascade";
+              };
+              required: true;
+              input: false;
+              index: true;
+            };
+            refillInterval: {
+              type: "number";
+              required: false;
+              input: false;
+            };
+            refillAmount: {
+              type: "number";
+              required: false;
+              input: false;
+            };
+            lastRefillAt: {
+              type: "date";
+              required: false;
+              input: false;
+            };
+            enabled: {
+              type: "boolean";
+              required: false;
+              input: false;
+              defaultValue: true;
+            };
+            rateLimitEnabled: {
+              type: "boolean";
+              required: false;
+              input: false;
+              defaultValue: true;
+            };
+            rateLimitTimeWindow: {
+              type: "number";
+              required: false;
+              input: false;
+              defaultValue: number;
+            };
+            rateLimitMax: {
+              type: "number";
+              required: false;
+              input: false;
+              defaultValue: number;
+            };
+            requestCount: {
+              type: "number";
+              required: false;
+              input: false;
+              defaultValue: number;
+            };
+            remaining: {
+              type: "number";
+              required: false;
+              input: false;
+            };
+            lastRequest: {
+              type: "date";
+              required: false;
+              input: false;
+            };
+            expiresAt: {
+              type: "date";
+              required: false;
+              input: false;
+            };
+            createdAt: {
+              type: "date";
+              required: true;
+              input: false;
+            };
+            updatedAt: {
+              type: "date";
+              required: true;
+              input: false;
+            };
+            permissions: {
+              type: "string";
+              required: false;
+              input: false;
+            };
+            metadata: {
+              type: "string";
+              required: false;
+              input: true;
+              transform: {
+                input(value: better_auth0.DBPrimitive): string;
+                output(value: better_auth0.DBPrimitive): any;
+              };
+            };
+          };
+        };
+      };
+      options: better_auth_plugins0.ApiKeyOptions | undefined;
+    }, {
+      id: "bearer";
+      hooks: {
+        before: {
+          matcher(context: better_auth0.HookEndpointContext): boolean;
+          handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+            context: {
+              headers: Headers;
+            };
+          } | undefined>;
+        }[];
+        after: {
+          matcher(context: better_auth0.HookEndpointContext): true;
+          handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+        }[];
+      };
+      options: better_auth_plugins0.BearerOptions | undefined;
+    }];
+    emailAndPassword: {
+      enabled: true;
+      requireEmailVerification: true;
+    };
+  }>>;
+  locale?: questpie181.LocaleConfig | undefined;
+  migrations?: questpie181.Migration[] | undefined;
+  translations?: questpie181.TranslationsConfig | undefined;
+  "~messageKeys"?: "error.notFound" | "error.notFound.withId" | "error.forbidden" | "error.unauthorized" | "error.validation" | "error.internal" | "error.badRequest" | "error.conflict" | "error.notImplemented" | "error.timeout" | "crud.create.forbidden" | "crud.read.forbidden" | "crud.update.forbidden" | "crud.delete.forbidden" | "crud.notFound" | "validation.required" | "validation.invalidType" | "validation.string.tooSmall" | "validation.string.tooBig" | "validation.string.email" | "validation.string.url" | "validation.string.uuid" | "validation.string.regex" | "validation.number.tooSmall" | "validation.number.tooBig" | "validation.number.notInteger" | "validation.number.notPositive" | "validation.number.notNegative" | "validation.array.tooSmall" | "validation.array.tooBig" | "validation.date.invalid" | "validation.date.tooEarly" | "validation.date.tooLate" | "auth.invalidCredentials" | "auth.sessionExpired" | "auth.tokenInvalid" | "auth.tokenExpired" | "auth.accountLocked" | "auth.emailNotVerified" | "auth.userNotFound" | "auth.userAlreadyExists" | "upload.tooLarge" | "upload.invalidType" | "upload.failed" | "hook.beforeCreate.failed" | "hook.afterCreate.failed" | "hook.beforeUpdate.failed" | "hook.afterUpdate.failed" | "hook.beforeDelete.failed" | "hook.afterDelete.failed" | "hook.validate.failed" | "access.denied" | "access.fieldDenied" | "access.operationDenied" | "error.database.uniqueViolation" | "error.database.foreignKeyViolation" | "error.database.notNullViolation" | "error.database.checkViolation" | undefined;
+}, "collections", {
+  user: questpie181.CollectionBuilder<{
+    options: {
+      timestamps: true;
+    };
+    name: "user";
+    fields: {
+      name: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      email: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      emailVerified: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgBooleanBuilder>;
+      image: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      role: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      banned: drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgBooleanBuilder>;
+      banReason: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      banExpires: drizzle_orm_pg_core183.PgTimestampBuilder;
+    };
+    localized: [];
+    virtuals: undefined;
+    relations: Record<string, questpie181.RelationConfig>;
+    indexes: Record<string, any>;
+    title: "name";
+    hooks: questpie181.CollectionHooks<any, any, any, any>;
+    access: questpie181.CollectionAccess<any, any>;
+    functions: {
+      [x: string]: questpie181.FunctionDefinition<any, any, any>;
+    };
+    searchable: undefined;
+    validation: undefined;
+    output: undefined;
+    upload: undefined;
+  }>;
+  session: questpie181.CollectionBuilder<{
+    options: questpie181.CollectionOptions;
+    name: "session";
+    fields: {
+      userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      token: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      expiresAt: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgTimestampBuilder>;
+      ipAddress: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      userAgent: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      impersonatedBy: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+    };
+    localized: [];
+    virtuals: undefined;
+    relations: Record<string, questpie181.RelationConfig>;
+    indexes: Record<string, any>;
+    title: "token";
+    hooks: questpie181.CollectionHooks<any, any, any, any>;
+    access: questpie181.CollectionAccess<any, any>;
+    functions: {
+      [x: string]: questpie181.FunctionDefinition<any, any, any>;
+    };
+    searchable: undefined;
+    validation: undefined;
+    output: undefined;
+    upload: undefined;
+  }>;
+  account: questpie181.CollectionBuilder<{
+    options: questpie181.CollectionOptions;
+    name: "account";
+    fields: {
+      userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      accountId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      providerId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      accessToken: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      refreshToken: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      accessTokenExpiresAt: drizzle_orm_pg_core183.PgTimestampBuilder;
+      refreshTokenExpiresAt: drizzle_orm_pg_core183.PgTimestampBuilder;
+      scope: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      idToken: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      password: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+    };
+    localized: [];
+    virtuals: undefined;
+    relations: Record<string, questpie181.RelationConfig>;
+    indexes: Record<string, any>;
+    title: "providerId";
+    hooks: questpie181.CollectionHooks<any, any, any, any>;
+    access: questpie181.CollectionAccess<any, any>;
+    functions: {
+      [x: string]: questpie181.FunctionDefinition<any, any, any>;
+    };
+    searchable: undefined;
+    validation: undefined;
+    output: undefined;
+    upload: undefined;
+  }>;
+  verification: questpie181.CollectionBuilder<{
+    options: questpie181.CollectionOptions;
+    name: "verification";
+    fields: {
+      identifier: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      value: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      expiresAt: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgTimestampBuilder>;
+    };
+    localized: [];
+    virtuals: undefined;
+    relations: Record<string, questpie181.RelationConfig>;
+    indexes: Record<string, any>;
+    title: "identifier";
+    hooks: questpie181.CollectionHooks<any, any, any, any>;
+    access: questpie181.CollectionAccess<any, any>;
+    functions: {
+      [x: string]: questpie181.FunctionDefinition<any, any, any>;
+    };
+    searchable: undefined;
+    validation: undefined;
+    output: undefined;
+    upload: undefined;
+  }>;
+  assets: questpie181.CollectionBuilder<{
+    options: {
+      timestamps: true;
+    };
+    name: "assets";
+    fields: {
+      width: drizzle_orm_pg_core183.PgIntegerBuilder;
+      height: drizzle_orm_pg_core183.PgIntegerBuilder;
+      alt: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      caption: drizzle_orm_pg_core183.PgTextBuilder<[string, ...string[]]>;
+    } & {
+      key: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      filename: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      mimeType: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      size: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgIntegerBuilder>;
+      visibility: drizzle_orm94.HasDefault<drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<["public", "private"]>>>;
+    };
+    localized: [];
+    virtuals: undefined;
+    relations: Record<string, questpie181.RelationConfig>;
+    indexes: Record<string, any>;
+    title: "filename";
+    hooks: {
+      afterDelete: ({
+        data,
+        app
+      }: questpie181.HookContext<{
+        width: number | null;
+        height: number | null;
+        alt: string | null;
+        caption: string | null;
+        visibility: "public" | "private";
+        id: string;
+        key: string;
+        filename: string;
+        size: number;
+        mimeType: string;
+        createdAt: Date;
+        updatedAt: Date;
+        _title: string;
+        url: string;
+      }, never, "delete", any>) => Promise<void>;
+    };
+    access: questpie181.CollectionAccess<any, any>;
+    functions: {
+      [x: string]: questpie181.FunctionDefinition<any, any, any>;
+    };
+    searchable: undefined;
+    validation: undefined;
+    output: questpie181.TypeMerge<{}, {
+      url: string;
+    }>;
+    upload: questpie181.UploadOptions;
+  }>;
+  apikey: questpie181.CollectionBuilder<{
+    options: {
+      timestamps: true;
+    };
+    name: "apikey";
+    fields: {
+      name: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      start: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      prefix: drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>;
+      key: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      refillInterval: drizzle_orm_pg_core183.PgIntegerBuilder;
+      refillAmount: drizzle_orm_pg_core183.PgIntegerBuilder;
+      lastRefillAt: drizzle_orm_pg_core183.PgTimestampBuilder;
+      enabled: drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgBooleanBuilder>;
+      rateLimitEnabled: drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgBooleanBuilder>;
+      rateLimitTimeWindow: drizzle_orm_pg_core183.PgIntegerBuilder;
+      rateLimitMax: drizzle_orm_pg_core183.PgIntegerBuilder;
+      requestCount: drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgIntegerBuilder>;
+      remaining: drizzle_orm_pg_core183.PgIntegerBuilder;
+      lastRequest: drizzle_orm_pg_core183.PgTimestampBuilder;
+      expiresAt: drizzle_orm_pg_core183.PgTimestampBuilder;
+      permissions: drizzle_orm_pg_core183.PgTextBuilder<[string, ...string[]]>;
+      metadata: drizzle_orm_pg_core183.PgTextBuilder<[string, ...string[]]>;
+    };
+    localized: [];
+    virtuals: undefined;
+    relations: Record<string, questpie181.RelationConfig>;
+    indexes: Record<string, any>;
+    title: "key";
+    hooks: questpie181.CollectionHooks<any, any, any, any>;
+    access: questpie181.CollectionAccess<any, any>;
+    functions: {
+      [x: string]: questpie181.FunctionDefinition<any, any, any>;
+    };
+    searchable: undefined;
+    validation: undefined;
+    output: undefined;
+    upload: undefined;
+  }>;
+  admin_saved_views: questpie181.CollectionBuilder<{
+    name: "admin_saved_views";
+    localized: [];
+    output: undefined;
+    title: undefined;
+    options: {
+      timestamps: true;
+    };
+    fields: {
+      userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      collectionName: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      name: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      configuration: drizzle_orm94.$Type<drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgJsonbBuilder>, ViewConfiguration>;
+      isDefault: drizzle_orm94.NotNull<drizzle_orm94.HasDefault<drizzle_orm_pg_core183.PgBooleanBuilder>>;
+    };
+    upload: undefined;
+    functions: {
+      [x: string]: questpie181.FunctionDefinition<any, any, any>;
+    };
+    hooks: questpie181.CollectionHooks<any, any, any, any>;
+    indexes: Record<string, any>;
+    searchable: undefined;
+    virtuals: undefined;
+    relations: Record<string, questpie181.RelationConfig>;
+    access: questpie181.CollectionAccess<any, any>;
+    validation: undefined;
+  }>;
+  admin_preferences: questpie181.CollectionBuilder<{
+    name: "admin_preferences";
+    localized: [];
+    output: undefined;
+    title: undefined;
+    options: {
+      timestamps: true;
+    };
+    fields: {
+      userId: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      key: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgVarcharBuilder<[string, ...string[]]>>;
+      value: drizzle_orm94.NotNull<drizzle_orm_pg_core183.PgJsonbBuilder>;
+    };
+    upload: undefined;
+    functions: {
+      [x: string]: questpie181.FunctionDefinition<any, any, any>;
+    };
+    hooks: questpie181.CollectionHooks<any, any, any, any>;
+    indexes: drizzle_orm_pg_core183.IndexBuilder[];
+    searchable: undefined;
+    virtuals: undefined;
+    relations: Record<string, questpie181.RelationConfig>;
+    access: questpie181.CollectionAccess<any, any>;
+    validation: undefined;
+  }>;
+}>, "functions", {
+  mintPreviewToken: questpie181.JsonFunctionDefinition<{
+    path: string;
+    ttlMs?: number | undefined;
+  }, {
+    token: string;
+    expiresAt: number;
+  }, any>;
+  verifyPreviewToken: questpie181.JsonFunctionDefinition<{
+    token: string;
+  }, {
+    valid: boolean;
+    path?: string | undefined;
+    error?: string | undefined;
+  }, any>;
+  getContentLocales: questpie181.JsonFunctionDefinition<Record<string, never> | undefined, {
+    locales: {
+      code: string;
+      label?: string | undefined;
+      fallback?: boolean | undefined;
+      flagCountryCode?: string | undefined;
+    }[];
+    defaultLocale: string;
+    fallbacks?: Record<string, string> | undefined;
+  }, any>;
+  isSetupRequired: questpie181.JsonFunctionDefinition<Record<string, never>, {
+    required: boolean;
+  }, any>;
+  createFirstAdmin: questpie181.JsonFunctionDefinition<{
+    email: string;
+    password: string;
+    name: string;
+  }, {
+    success: boolean;
+    user?: {
+      id: string;
+      email: string;
+      name: string;
+    } | undefined;
+    error?: string | undefined;
+  }, any>;
+}>>;
+//#endregion
+export { PreviewTokenPayload as a, verifyPreviewTokenDirect as c, GetAdminSessionOptions as d, RequireAdminAuthOptions as f, requireAdminAuth as h, setupFunctions as i, savedViewsCollection as l, isAdminUser as m, createFirstAdmin as n, createPreviewFunctions as o, getAdminSession as p, isSetupRequired as r, createPreviewTokenVerifier as s, adminModule as t, AuthSession as u };
+//# sourceMappingURL=index-B9Xwk4hi.d.mts.map