@questpie/admin 1.1.1 → 3.0.0

package/dist/server/modules/admin/index.d.mts

@@ -0,0 +1,1093 @@
+import { ExecuteActionRequest, ExecuteActionResponse, actionFunctions, executeAction, executeActionFn, getActionsConfig, getActionsConfigFn } from "./routes/execute-action.mjs";
+import { PreviewTokenPayload, createPreviewFunctions, createPreviewTokenVerifier, verifyPreviewTokenDirect } from "./routes/preview.mjs";
+import { batchReactive, fieldOptions, reactiveFunctions } from "./routes/reactive.mjs";
+import { createFirstAdmin, isSetupRequired, setupFunctions } from "./routes/setup.mjs";
+import { fetchWidgetData, widgetDataFunctions } from "./routes/widget-data.mjs";
+import { AdminCollections, AdminComponents, AdminRoutes, AdminViews } from "./.generated/module.mjs";
+import { FilterOperator, FilterRule, SortConfig, ViewConfiguration } from "../../../shared/types/saved-views.types.mjs";
+import { savedViewsCollection } from "../admin-preferences/collections/saved-views.mjs";
+import "./index.mjs";
+import * as zod0 from "zod";
+import * as questpie0 from "questpie";
+import * as better_auth0 from "better-auth";
+import * as better_call0 from "better-call";
+import * as better_auth_plugins0 from "better-auth/plugins";
+import * as questpie_src_server_modules_core_fields_email_js0 from "questpie/src/server/modules/core/fields/email.js";
+import * as questpie_src_server_modules_core_fields_json_js0 from "questpie/src/server/modules/core/fields/json.js";
+
+//#region src/server/modules/admin/index.d.ts
+
+/**
+ * Admin module with codegen plugin attached.
+ *
+ * The `plugin` field lets `extractPluginsFromModules` auto-discover the admin
+ * codegen plugin from modules.ts, eliminating the need for users to manually
+ * add `plugins: [adminPlugin()]` in their questpie.config.ts.
+ */
+declare const adminModule: {
+  name: "questpie-admin";
+  modules: readonly [{
+    name: "questpie-starter";
+    collections: questpie0.StarterCollections;
+    jobs: questpie0.StarterJobs;
+    messages: {
+      en: {
+        readonly "error.notFound": "Resource not found";
+        readonly "error.notFound.withId": "{{resource}} with ID {{id}} not found";
+        readonly "error.forbidden": "Access forbidden";
+        readonly "error.unauthorized": "Unauthorized";
+        readonly "error.validation": "Validation failed";
+        readonly "error.internal": "Internal server error";
+        readonly "error.badRequest": "Bad request";
+        readonly "error.conflict": "Resource conflict";
+        readonly "error.notImplemented": "Not implemented";
+        readonly "error.timeout": "Request timeout";
+        readonly "crud.create.forbidden": "You don't have permission to create this resource";
+        readonly "crud.read.forbidden": "You don't have permission to read this resource";
+        readonly "crud.update.forbidden": "You don't have permission to update this resource";
+        readonly "crud.delete.forbidden": "You don't have permission to delete this resource";
+        readonly "crud.notFound": "{{resource}} not found";
+        readonly "validation.required": "{{field}} is required";
+        readonly "validation.invalidType": "{{field}} must be a {{expected}}";
+        readonly "validation.string.tooSmall": "{{field}} must be at least {{min}} characters";
+        readonly "validation.string.tooBig": "{{field}} must be at most {{max}} characters";
+        readonly "validation.string.email": "{{field}} must be a valid email";
+        readonly "validation.string.url": "{{field}} must be a valid URL";
+        readonly "validation.string.uuid": "{{field}} must be a valid UUID";
+        readonly "validation.string.regex": "{{field}} has invalid format";
+        readonly "validation.number.tooSmall": "{{field}} must be at least {{min}}";
+        readonly "validation.number.tooBig": "{{field}} must be at most {{max}}";
+        readonly "validation.number.notInteger": "{{field}} must be an integer";
+        readonly "validation.number.notPositive": "{{field}} must be positive";
+        readonly "validation.number.notNegative": "{{field}} must be negative";
+        readonly "validation.array.tooSmall": "{{field}} must have at least {{min}} items";
+        readonly "validation.array.tooBig": "{{field}} must have at most {{max}} items";
+        readonly "validation.date.invalid": "{{field}} must be a valid date";
+        readonly "validation.date.tooEarly": "{{field}} must be after {{min}}";
+        readonly "validation.date.tooLate": "{{field}} must be before {{max}}";
+        readonly "auth.invalidCredentials": "Invalid credentials";
+        readonly "auth.sessionExpired": "Session expired";
+        readonly "auth.tokenInvalid": "Invalid token";
+        readonly "auth.tokenExpired": "Token expired";
+        readonly "auth.accountLocked": "Account locked";
+        readonly "auth.emailNotVerified": "Email not verified";
+        readonly "auth.userNotFound": "User not found";
+        readonly "auth.userAlreadyExists": "User already exists";
+        readonly "upload.tooLarge": "File too large (max {{max}})";
+        readonly "upload.invalidType": "Invalid file type. Allowed: {{allowed}}";
+        readonly "upload.failed": "Upload failed";
+        readonly "hook.beforeCreate.failed": "Pre-create validation failed";
+        readonly "hook.afterCreate.failed": "Post-create processing failed";
+        readonly "hook.beforeUpdate.failed": "Pre-update validation failed";
+        readonly "hook.afterUpdate.failed": "Post-update processing failed";
+        readonly "hook.beforeDelete.failed": "Pre-delete validation failed";
+        readonly "hook.afterDelete.failed": "Post-delete processing failed";
+        readonly "hook.validate.failed": "Validation hook failed";
+        readonly "access.denied": "Access denied";
+        readonly "access.fieldDenied": "Access to field {{field}} denied";
+        readonly "access.operationDenied": "Operation {{operation}} not allowed";
+        readonly "error.database.uniqueViolation": "{{field}} already exists";
+        readonly "error.database.foreignKeyViolation": "Referenced {{resource}} does not exist";
+        readonly "error.database.notNullViolation": "{{field}} cannot be null";
+        readonly "error.database.checkViolation": "{{field}} violates check constraint";
+      };
+    };
+    globals: {};
+    routes: {};
+    services: {};
+    emails: {};
+    migrations: readonly [];
+    seeds: readonly [];
+    fieldTypes: {};
+    config: {
+      app: {
+        access: {
+          read: ({
+            session
+          }: any) => boolean;
+          create: ({
+            session
+          }: any) => boolean;
+          update: ({
+            session
+          }: any) => boolean;
+          delete: ({
+            session
+          }: any) => boolean;
+        };
+      };
+      auth: {
+        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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              user: {
+                                $ref: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+                $Infer: {
+                  body: {
+                    userId: string;
+                    role: "user" | "admin" | ("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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              user: {
+                                $ref: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, 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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              user: {
+                                $ref: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, 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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              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.ZodUnion<[zod0.ZodUnion<[zod0.ZodString, zod0.ZodNumber]>, zod0.ZodBoolean]>, zod0.ZodArray<zod0.ZodString>]>, zod0.ZodArray<zod0.ZodNumber>]>>;
+                filterOperator: zod0.ZodOptional<zod0.ZodEnum<{
+                  eq: "eq";
+                  ne: "ne";
+                  gt: "gt";
+                  gte: "gte";
+                  lt: "lt";
+                  lte: "lte";
+                  in: "in";
+                  not_in: "not_in";
+                  contains: "contains";
+                  starts_with: "starts_with";
+                  ends_with: "ends_with";
+                }>>;
+              }, 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;
+            }>;
+            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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              user: {
+                                $ref: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, {
+              user: 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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              user: {
+                                $ref: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, {
+              user: 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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              session: {
+                                $ref: string;
+                              };
+                              user: {
+                                $ref: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, {
+              session: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: 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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              success: {
+                                type: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, {
+              success: boolean;
+            }>;
+            revokeUserSessions: 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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              success: {
+                                type: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, {
+              success: boolean;
+            }>;
+            removeUser: 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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              success: {
+                                type: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, {
+              success: boolean;
+            }>;
+            setUserPassword: 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: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                  };
+                };
+              }>)[];
+              metadata: {
+                openapi: {
+                  operationId: string;
+                  summary: string;
+                  description: string;
+                  responses: {
+                    200: {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              status: {
+                                type: string;
+                              };
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            }, {
+              status: boolean;
+            }>;
+            userHasPermission: 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: {
+                            permissions: {
+                              type: string;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                        };
+                      };
+                    };
+                  };
+                  responses: {
+                    "200": {
+                      description: string;
+                      content: {
+                        "application/json": {
+                          schema: {
+                            type: "object";
+                            properties: {
+                              error: {
+                                type: string;
+                              };
+                              success: {
+                                type: string;
+                              };
+                            };
+                            required: string[];
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+                $Infer: {
+                  body: {
+                    permissions: {
+                      readonly user?: ("delete" | "list" | "create" | "set-role" | "ban" | "impersonate" | "impersonate-admins" | "set-password" | "get" | "update")[] | undefined;
+                      readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                    };
+                  } & {
+                    userId?: string | undefined;
+                    role?: "user" | "admin" | undefined;
+                  };
+                };
+              };
+            }, {
+              error: null;
+              success: boolean;
+            }>;
+          };
+          $ERROR_CODES: {
+            USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: better_auth0.RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+            FAILED_TO_CREATE_USER: better_auth0.RawError<"FAILED_TO_CREATE_USER">;
+            USER_ALREADY_EXISTS: better_auth0.RawError<"USER_ALREADY_EXISTS">;
+            YOU_CANNOT_BAN_YOURSELF: better_auth0.RawError<"YOU_CANNOT_BAN_YOURSELF">;
+            YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+            YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+            BANNED_USER: better_auth0.RawError<"BANNED_USER">;
+            YOU_ARE_NOT_ALLOWED_TO_GET_USER: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+            NO_DATA_TO_UPDATE: better_auth0.RawError<"NO_DATA_TO_UPDATE">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+            YOU_CANNOT_REMOVE_YOURSELF: better_auth0.RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+            YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+            YOU_CANNOT_IMPERSONATE_ADMINS: better_auth0.RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+            INVALID_ROLE_TYPE: better_auth0.RawError<"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: "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: boolean;
+          requireEmailVerification: boolean;
+        };
+      };
+    };
+    fields: {
+      readonly text: typeof questpie0.text;
+      readonly textarea: typeof questpie0.textarea;
+      readonly email: typeof questpie_src_server_modules_core_fields_email_js0.email;
+      readonly url: typeof questpie0.url;
+      readonly number: typeof questpie0.number;
+      readonly boolean: typeof questpie0.boolean;
+      readonly date: typeof questpie0.date;
+      readonly datetime: typeof questpie0.datetime;
+      readonly time: typeof questpie0.time;
+      readonly select: typeof questpie0.select;
+      readonly upload: typeof questpie0.upload;
+      readonly relation: typeof questpie0.relation;
+      readonly object: typeof questpie0.object;
+      readonly json: typeof questpie_src_server_modules_core_fields_json_js0.json;
+      readonly from: typeof questpie0.from;
+    };
+  }];
+  collections: AdminCollections;
+  routes: AdminRoutes;
+  views: AdminViews;
+  components: AdminComponents;
+  globals: {};
+  jobs: {};
+  messages: {};
+  services: {};
+  emails: {};
+  migrations: readonly [];
+  seeds: readonly [];
+  fieldTypes: {};
+  blocks: {};
+  config: {
+    admin: {
+      sidebar: {
+        sections: {
+          id: string;
+          title: {
+            key: string;
+          };
+        }[];
+        items: {
+          sectionId: string;
+          type: "collection";
+          collection: string;
+          icon: {
+            type: string;
+            props: {
+              name: string;
+            };
+          };
+        }[];
+      };
+    };
+  };
+  plugin: questpie0.CodegenPlugin;
+} & {
+  plugin: questpie0.CodegenPlugin;
+};
+type AdminModule = typeof adminModule;
+/**
+ * Admin routes — flat spread of all admin route definitions.
+ * Automatically registered when adminModule is included in your app modules.
+ */
+declare const adminRoutes: AdminRoutes;
+//#endregion
+export { AdminModule, adminModule, adminRoutes };