@protobase/server 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,1252 @@
+import { Mailer } from "../mail/smtp-mailer.js";
+import { BetterAuthOptions } from "better-auth";
+//#region src/better-auth/create-auth.d.ts
+export type CreateAuthOptions = {
+  /** A `pg` Pool, or `{ dialect, type: 'postgres', schemaName? }` for a Kysely dialect: the admin store, apart from the application's tables (its own schema or database). */
+  database: BetterAuthOptions['database'];
+  /** Public origin of the API, for example `https://admin.example.com`. Issuer and audience of the tokens. */
+  baseURL: string;
+  /** Signs cookies and encrypts the JWT private keys. Generate with `openssl rand -base64 32`. */
+  secret: string;
+  /** Extra origins that may call the auth endpoints. `baseURL` and `https://*.trycloudflare.com` are always trusted. */
+  trustedOrigins?: string[];
+  /** The roles users can have, for example `['admin', 'accountant', 'warehouse']`. `admin` is always included; default `['admin', 'user']`. */
+  roles?: string[];
+  /**
+   * The role of a user created without one. Optional: when unset, and more than one role besides `admin` exists,
+   * creating a user without a role is an error that asks for one. With exactly one other role, that role is the default.
+   */
+  defaultRole?: string;
+  /** Sign-in attempts allowed per minute and client, default 5. */
+  signInPerMinute?: number;
+  /**
+   * Sends the password-reset email; without a mailer there is no password reset. Defaults to SMTP with the settings
+   * the platform passes in `PROTOBASE_SMTP_URL` and `PROTOBASE_MAIL_FROM` (see `readMailSettings`), when set; `false`
+   * turns reset off whatever the environment says.
+   */
+  mailer?: Mailer | false;
+  /**
+   * Sign-in providers for Better Auth, for example `{ github: { clientId, clientSecret } }`; the callback is
+   * `{baseURL}/api/auth/callback/<provider>`. A provider also signs up people without an account, with the default role.
+   * Default none.
+   */
+  socialProviders?: BetterAuthOptions['socialProviders'];
+};
+/** The configured roles with `admin` first; `admin` is added when missing. */
+export declare const normalizeRoles: (roles?: string[]) => string[];
+export declare const createAuth: (options: CreateAuthOptions) => import("better-auth").Auth<{
+  plugins: [{
+    id: "admin";
+    version: string;
+    init(): {
+      options: {
+        databaseHooks: {
+          user: {
+            create: {
+              before(user: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              } & Record<string, unknown>): Promise<{
+                data: {
+                  id: string;
+                  createdAt: Date;
+                  updatedAt: Date;
+                  email: string;
+                  emailVerified: boolean;
+                  name: string;
+                  image?: string | null | undefined;
+                  role: string;
+                };
+              }>;
+            };
+          };
+          session: {
+            create: {
+              before(session: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              } & Record<string, unknown>, ctx: import("better-auth").GenericEndpointContext | null): Promise<void>;
+            };
+          };
+        };
+      };
+    };
+    hooks: {
+      after: {
+        matcher(context: import("better-auth").HookEndpointContext): boolean;
+        handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>>;
+      }[];
+    };
+    endpoints: {
+      setRole: import("better-auth").StrictEndpoint<"/admin/set-role", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+          role: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
+        }, import("zod/v4/core").$strip>;
+        requireHeaders: true;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+          $Infer: {
+            body: {
+              userId: string;
+              role: string | number | (string | number)[];
+            };
+          };
+        };
+      }, {
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      getUser: import("better-auth").StrictEndpoint<"/admin/get-user", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+          id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, import("better-auth/plugins").UserWithRole>;
+      createUser: import("better-auth").StrictEndpoint<"/admin/create-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          password: import("zod").ZodOptional<import("zod").ZodString>;
+          name: import("zod").ZodString;
+          role: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+          data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+          $Infer: {
+            body: {
+              email: string;
+              password?: string | undefined;
+              name: string;
+              role?: string | number | (string | number)[] | undefined;
+              data?: Record<string, any> | undefined;
+            };
+          };
+        };
+      }, {
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      adminUpdateUser: import("better-auth").StrictEndpoint<"/admin/update-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+          data: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, import("better-auth/plugins").UserWithRole>;
+      listUsers: import("better-auth").StrictEndpoint<"/admin/list-users", {
+        method: "GET";
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        query: import("zod").ZodObject<{
+          searchValue: import("zod").ZodOptional<import("zod").ZodString>;
+          searchField: import("zod").ZodOptional<import("zod").ZodEnum<{
+            email: "email";
+            name: "name";
+          }>>;
+          searchOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+            contains: "contains";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+          }>>;
+          limit: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+          offset: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+          sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+          sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+          }>>;
+          filterField: import("zod").ZodOptional<import("zod").ZodString>;
+          filterValue: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, import("zod").ZodBoolean]>, import("zod").ZodArray<import("zod").ZodString>]>, import("zod").ZodArray<import("zod").ZodNumber>]>>;
+          filterOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+            in: "in";
+            lte: "lte";
+            eq: "eq";
+            ne: "ne";
+            lt: "lt";
+            gt: "gt";
+            gte: "gte";
+            not_in: "not_in";
+            contains: "contains";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+          }>>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        users: {
+                          type: string;
+                          items: {
+                            $ref: string;
+                          };
+                        };
+                        total: {
+                          type: string;
+                        };
+                        limit: {
+                          type: string;
+                        };
+                        offset: {
+                          type: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        users: import("better-auth/plugins").UserWithRole[];
+        total: number;
+      }>;
+      listUserSessions: import("better-auth").StrictEndpoint<"/admin/list-user-sessions", {
+        method: "POST";
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        sessions: {
+                          type: string;
+                          items: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
+      }>;
+      unbanUser: import("better-auth").StrictEndpoint<"/admin/unban-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      banUser: import("better-auth").StrictEndpoint<"/admin/ban-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+          banReason: import("zod").ZodOptional<import("zod").ZodString>;
+          banExpiresIn: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      impersonateUser: import("better-auth").StrictEndpoint<"/admin/impersonate-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        session: {
+                          $ref: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      stopImpersonating: import("better-auth").StrictEndpoint<"/admin/stop-impersonating", {
+        method: "POST";
+        requireHeaders: true;
+      }, {
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        } & Record<string, any>;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & Record<string, any>;
+      }>;
+      revokeUserSession: import("better-auth").StrictEndpoint<"/admin/revoke-user-session", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          sessionToken: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      revokeUserSessions: import("better-auth").StrictEndpoint<"/admin/revoke-user-sessions", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      removeUser: import("better-auth").StrictEndpoint<"/admin/remove-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      setUserPassword: import("better-auth").StrictEndpoint<"/admin/set-user-password", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          newPassword: import("zod").ZodString;
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>>[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        status: boolean;
+      }>;
+      userHasPermission: import("better-auth").StrictEndpoint<"/admin/has-permission", {
+        method: "POST";
+        body: import("zod").ZodIntersection<import("zod").ZodObject<{
+          userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+          role: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodXor<readonly [import("zod").ZodObject<{
+          permission: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+          permissions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>]>>;
+        metadata: {
+          openapi: {
+            description: string;
+            requestBody: {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      permissions: {
+                        type: string;
+                        description: string;
+                      };
+                    };
+                    required: string[];
+                  };
+                };
+              };
+            };
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        error: {
+                          type: string;
+                        };
+                        success: {
+                          type: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+          $Infer: {
+            body: {
+              permissions: {
+                readonly user?: ("create" | "list" | "set-role" | "ban" | "impersonate" | "delete" | "set-password" | "set-email" | "get" | "update" | "impersonate-admins")[] | undefined;
+                readonly session?: ("list" | "delete" | "revoke")[] | undefined;
+              };
+            } & {
+              userId?: string | undefined;
+              role?: string | number | undefined;
+            };
+          };
+        };
+      }, {
+        error: null;
+        success: boolean;
+      }>;
+    };
+    $ERROR_CODES: {
+      USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: import("better-auth").RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+      FAILED_TO_CREATE_USER: import("better-auth").RawError<"FAILED_TO_CREATE_USER">;
+      USER_ALREADY_EXISTS: import("better-auth").RawError<"USER_ALREADY_EXISTS">;
+      YOU_CANNOT_BAN_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_BAN_YOURSELF">;
+      YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+      YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+      YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+      YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+      BANNED_USER: import("better-auth").RawError<"BANNED_USER">;
+      YOU_ARE_NOT_ALLOWED_TO_GET_USER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+      NO_DATA_TO_UPDATE: import("better-auth").RawError<"NO_DATA_TO_UPDATE">;
+      YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+      YOU_CANNOT_REMOVE_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+      YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+      YOU_CANNOT_IMPERSONATE_ADMINS: import("better-auth").RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+      INVALID_ROLE_TYPE: import("better-auth").RawError<"INVALID_ROLE_TYPE">;
+      YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL">;
+      PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER: import("better-auth").RawError<"PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER">;
+    };
+    schema: {
+      user: {
+        fields: {
+          role: {
+            type: "string";
+            required: false;
+            input: false;
+          };
+          banned: {
+            type: "boolean";
+            defaultValue: false;
+            required: false;
+            input: false;
+          };
+          banReason: {
+            type: "string";
+            required: false;
+            input: false;
+          };
+          banExpires: {
+            type: "date";
+            required: false;
+            input: false;
+          };
+        };
+      };
+      session: {
+        fields: {
+          impersonatedBy: {
+            type: "string";
+            required: false;
+            input: false;
+          };
+        };
+      };
+    };
+    options: NoInfer<{
+      defaultRole: string;
+      roles: {
+        [k: string]: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+          readonly user: ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "set-email", "get", "update"];
+          readonly session: ["list", "revoke", "delete"];
+        }>, {
+          readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+          readonly session: readonly ["list", "revoke", "delete"];
+        }> | import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+          readonly user: [];
+          readonly session: [];
+        }>, {
+          readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+          readonly session: readonly ["list", "revoke", "delete"];
+        }>;
+      };
+    }>;
+  }, {
+    id: "jwt";
+    version: string;
+    options: NoInfer<{
+      jwt: {
+        expirationTime: string;
+        issuer: string;
+        audience: string;
+        definePayload: ({ user }: {
+          user: import("better-auth").User & Record<string, any>;
+          session: import("better-auth").Session & Record<string, any>;
+        }) => {
+          email: string;
+          role: any;
+        };
+      };
+    }>;
+    init(ctx: import("better-auth").AuthContext): {
+      context: {
+        sessionConfig: {
+          cookieCacheSigner: import("better-auth").CookieCacheSigner;
+          updateAge: number;
+          expiresIn: number;
+          freshAge: number;
+          cookieRefreshCache: false | {
+            enabled: true;
+            updateAge: number;
+          };
+        };
+      };
+    } | undefined;
+    endpoints: {
+      getJwks: import("better-auth").StrictEndpoint<string, {
+        method: "GET";
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        keys: {
+                          type: string;
+                          description: string;
+                          items: {
+                            type: string;
+                            properties: {
+                              kid: {
+                                type: string;
+                                description: string;
+                              };
+                              kty: {
+                                type: string;
+                                description: string;
+                              };
+                              alg: {
+                                type: string;
+                                description: string;
+                              };
+                              use: {
+                                type: string;
+                                description: string;
+                                enum: string[];
+                                nullable: boolean;
+                              };
+                              n: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                              e: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                              crv: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                              x: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                              y: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                            };
+                            required: string[];
+                          };
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, import("jose").JSONWebKeySet>;
+      getToken: import("better-auth").StrictEndpoint<"/token", {
+        method: "GET";
+        requireHeaders: true;
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        token: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        token: string;
+      }>;
+      signJWT: import("better-auth").StrictEndpoint<string, {
+        method: "POST";
+        metadata: {
+          $Infer: {
+            body: {
+              payload: import("jose").JWTPayload;
+              overrideOptions?: import("better-auth/plugins").JwtOptions | undefined;
+            };
+          };
+        };
+        body: import("zod").ZodObject<{
+          payload: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>;
+          overrideOptions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        }, import("zod/v4/core").$strip>;
+      }, {
+        token: string;
+      }>;
+      verifyJWT: import("better-auth").StrictEndpoint<string, {
+        method: "POST";
+        metadata: {
+          $Infer: {
+            body: {
+              token: string;
+              issuer?: string;
+            };
+            response: {
+              payload: {
+                sub: string;
+                aud: string;
+                [key: string]: any;
+              } | null;
+            };
+          };
+        };
+        body: import("zod").ZodObject<{
+          token: import("zod").ZodString;
+          issuer: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+      }, {
+        payload: (import("jose").JWTPayload & Required<Pick<import("jose").JWTPayload, "sub" | "aud">>) | null;
+      }>;
+    };
+    hooks: {
+      after: {
+        matcher(context: import("better-auth").HookEndpointContext): boolean;
+        handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+      }[];
+    };
+    schema: {
+      jwks: {
+        fields: {
+          publicKey: {
+            type: "string";
+            required: true;
+          };
+          privateKey: {
+            type: "string";
+            required: true;
+          };
+          createdAt: {
+            type: "date";
+            required: true;
+          };
+          expiresAt: {
+            type: "date";
+            required: false;
+          };
+          alg: {
+            type: "string";
+            required: false;
+          };
+          crv: {
+            type: "string";
+            required: false;
+          };
+        };
+      };
+    };
+  }];
+  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;
+          } & Record<string, unknown>;
+        }>;
+      };
+    };
+  };
+  rateLimit: {
+    enabled: true;
+    window: number;
+    max: number;
+    customRules: {
+      '/sign-in/email': {
+        window: number;
+        max: number;
+      };
+    };
+  };
+  advanced: {
+    useSecureCookies: boolean;
+    defaultCookieAttributes: {
+      sameSite: "lax";
+      secure: boolean;
+    };
+    backgroundTasks: {
+      handler: () => void;
+    };
+  };
+  socialProviders?: import("better-auth").SocialProviders | undefined;
+  database: any;
+  baseURL: string;
+  basePath: string;
+  secret: string;
+  trustedOrigins: string[];
+  emailAndPassword: {
+    resetPasswordTokenExpiresIn?: number | undefined;
+    revokeSessionsOnPasswordReset?: true | undefined;
+    sendResetPassword?: (({ user, url }: {
+      user: import("better-auth").User;
+      url: string;
+      token: string;
+    }) => Promise<void>) | undefined;
+    enabled: true;
+    disableSignUp: true;
+    minPasswordLength: number;
+  };
+}> & {
+  roles: string[];
+  defaultRole: string | undefined;
+  passwordReset: boolean;
+  socialProviders: string[];
+};
+export type AdminAuth = ReturnType<typeof createAuth>;
+//#endregion