@protobase/server 0.3.4 → 0.4.1

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

@@ -1,11 +1,16 @@
+import { SignInPolicy } from "./sign-in-policy.js";
+import { StaffSignIn } from "./staff-log.js";
 import { Mailer } from "../mail/smtp-mailer.js";
+import { OperatorProvider } from "./operator-provider.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. */
+  /** Public origin of the API, for example `https://admin.example.com`. Issuer and audience of the tokens; passkeys belong to its host. */
   baseURL: string;
+  /** The name authenticator apps and passkey prompts show for this app. Default `Protobase`. */
+  appName?: 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. */
@@ -20,9 +25,9 @@ export type CreateAuthOptions = {
   /** 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.
+   * Sends the password-reset email and the emailed sign-in and two-factor codes; without a mailer none of them is
+   * offered. Defaults to SMTP with the settings the platform passes in `PROTOBASE_SMTP_URL` and `PROTOBASE_MAIL_FROM`
+   * (see `readMailSettings`), when set; `false` turns mail off whatever the environment says.
    */
   mailer?: Mailer | false;
   /**
@@ -35,6 +40,13 @@ export type CreateAuthOptions = {
   encryptOAuthTokens?: boolean;
   /** Runs after a user is created, by any route: `createUser`, an admin, or a social sign-up. Default none. */
   onUserCreated?: UserCreatedHook;
+  /**
+   * The identity provider the operator's staff sign in with to sign in as people of this app, for support. Defaults
+   * to the one the platform passes in `PROTOBASE_OPERATOR_ISSUER`, `PROTOBASE_OPERATOR_CLIENT_ID` and
+   * `PROTOBASE_OPERATOR_CLIENT_SECRET` (see `readOperatorSettings`), when set; `false` turns staff sign-in off
+   * whatever the environment says.
+   */
+  operator?: OperatorProvider | false;
 };
 type UserCreateHooks = NonNullable<NonNullable<NonNullable<BetterAuthOptions['databaseHooks']>['user']>['create']>;
 /** Better Auth's `databaseHooks.user.create.after`: the created user (with its `role`) and the request context, `null` outside a request. */
@@ -961,6 +973,7 @@ export declare const createAuth: (options: CreateAuthOptions) => import("better-
           role: any;
         };
       };
+      disableSettingJwtHeader: true;
     }>;
     init(ctx: import("better-auth").AuthContext): {
       context: {
@@ -1184,12 +1197,261 @@ export declare const createAuth: (options: CreateAuthOptions) => import("better-
         };
       };
     };
-  }];
-  databaseHooks: {
-    user: {
-      create: {
-        after?: ((user: import("better-auth").User & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null) => Promise<void>) | undefined;
-        before: (user: {
+  }, {
+    hooks: {
+      after: {
+        matcher: (context: Parameters<(context: import("better-auth").HookEndpointContext) => boolean>[0]) => boolean;
+        handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          twoFactorRedirect: boolean;
+          twoFactorMethods: string[];
+        } | undefined>>;
+      }[];
+    };
+    id: "two-factor";
+    version: string;
+    endpoints: {
+      enableTwoFactor: import("better-auth").StrictEndpoint<"/two-factor/enable", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          password: import("zod").ZodOptional<import("zod").ZodString>;
+          method: import("zod").ZodDefault<import("zod").ZodEnum<{
+            otp: "otp";
+            totp: "totp";
+          }>>;
+          issuer: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+          password: import("zod").ZodString;
+          method: import("zod").ZodDefault<import("zod").ZodEnum<{
+            otp: "otp";
+            totp: "totp";
+          }>>;
+          issuer: import("zod").ZodOptional<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: {
+            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: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        method: {
+                          type: string;
+                          enum: string[];
+                          description: string;
+                        };
+                        totpURI: {
+                          type: string;
+                          description: string;
+                        };
+                        backupCodes: {
+                          type: string;
+                          items: {
+                            type: string;
+                          };
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        method: "otp";
+      } | {
+        method: "totp";
+        totpURI: string;
+        backupCodes: string[];
+      }>;
+      disableTwoFactor: import("better-auth").StrictEndpoint<"/two-factor/disable", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          password: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+          password: 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: {
+            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: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        status: boolean;
+      }>;
+      verifyBackupCode: import("better-auth").StrictEndpoint<"/two-factor/verify-backup-code", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          code: import("zod").ZodString;
+          disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+          trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          type: string;
+                          properties: {
+                            id: {
+                              type: string;
+                              description: string;
+                            };
+                            email: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            emailVerified: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            name: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            image: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            twoFactorEnabled: {
+                              type: string;
+                              description: string;
+                            };
+                            createdAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            updatedAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                          description: string;
+                        };
+                        session: {
+                          type: string;
+                          properties: {
+                            token: {
+                              type: string;
+                              description: string;
+                            };
+                            userId: {
+                              type: string;
+                              description: string;
+                            };
+                            createdAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            expiresAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        token: string | undefined;
+        user: (Record<string, any> & {
           id: string;
           createdAt: Date;
           updatedAt: Date;
@@ -1197,26 +1459,2088 @@ export declare const createAuth: (options: CreateAuthOptions) => import("better-
           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': {
+        }) | import("better-auth/plugins").UserWithTwoFactor;
+      }>;
+      generateBackupCodes: import("better-auth").StrictEndpoint<"/two-factor/generate-backup-codes", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          password: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+          password: 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: {
+            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: {
+                        status: {
+                          type: string;
+                          description: string;
+                          enum: boolean[];
+                        };
+                        backupCodes: {
+                          type: string;
+                          items: {
+                            type: string;
+                          };
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        status: boolean;
+        backupCodes: string[];
+      }>;
+      viewBackupCodes: import("better-auth").StrictEndpoint<string, {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+      }, {
+        status: boolean;
+        backupCodes: string[];
+      }>;
+      sendTwoFactorOTP: import("better-auth").StrictEndpoint<"/two-factor/send-otp", {
+        method: "POST";
+        body: import("zod").ZodOptional<import("zod").ZodObject<{
+          trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        status: boolean;
+      }>;
+      verifyTwoFactorOTP: import("better-auth").StrictEndpoint<"/two-factor/verify-otp", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          code: import("zod").ZodString;
+          trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        token: {
+                          type: string;
+                          description: string;
+                        };
+                        user: {
+                          type: string;
+                          properties: {
+                            id: {
+                              type: string;
+                              description: string;
+                            };
+                            email: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            emailVerified: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            name: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            image: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            createdAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            updatedAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        token: string;
+        user: import("better-auth/plugins").UserWithTwoFactor;
+      } | {
+        token: string;
+        user: Record<string, any> & {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+      }>;
+      generateTOTP: import("better-auth").StrictEndpoint<string, {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          secret: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        code: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        code: string;
+      }>;
+      getTOTPURI: import("better-auth").StrictEndpoint<"/two-factor/get-totp-uri", {
+        method: "POST";
+        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;
+            };
+          };
+        }>>[];
+        body: import("zod").ZodObject<{
+          password: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+          password: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        totpURI: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        totpURI: string;
+      }>;
+      verifyTOTP: import("better-auth").StrictEndpoint<"/two-factor/verify-totp", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          code: import("zod").ZodString;
+          trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        token: string;
+        user: import("better-auth/plugins").UserWithTwoFactor;
+      } | {
+        token: string;
+        user: Record<string, any> & {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+      }>;
+    };
+    options: NoInfer<import("better-auth/plugins").TwoFactorOptions>;
+    schema: {
+      user: {
+        fields: {
+          twoFactorEnabled: {
+            type: "boolean";
+            required: false;
+            defaultValue: false;
+            input: false;
+          };
+        };
+      };
+      twoFactor: {
+        fields: {
+          secret: {
+            type: "string";
+            required: true;
+            returned: false;
+            index: true;
+          };
+          backupCodes: {
+            type: "string";
+            required: true;
+            returned: false;
+          };
+          userId: {
+            type: "string";
+            required: true;
+            returned: false;
+            references: {
+              model: string;
+              field: string;
+            };
+            index: true;
+          };
+          verified: {
+            type: "boolean";
+            required: false;
+            defaultValue: true;
+            input: false;
+          };
+          failedVerificationCount: {
+            type: "number";
+            required: false;
+            defaultValue: number;
+            input: false;
+            returned: false;
+          };
+          lockedUntil: {
+            type: "date";
+            required: false;
+            input: false;
+            returned: false;
+          };
+        };
+      };
+    };
+    rateLimit: {
+      pathMatcher(path: string): boolean;
+      window: number;
+      max: number;
+    }[];
+    $ERROR_CODES: {
+      OTP_NOT_ENABLED: import("better-auth").RawError<"OTP_NOT_ENABLED">;
+      OTP_NOT_CONFIGURED: import("better-auth").RawError<"OTP_NOT_CONFIGURED">;
+      OTP_HAS_EXPIRED: import("better-auth").RawError<"OTP_HAS_EXPIRED">;
+      TOTP_NOT_ENABLED: import("better-auth").RawError<"TOTP_NOT_ENABLED">;
+      TOTP_ALREADY_ENABLED: import("better-auth").RawError<"TOTP_ALREADY_ENABLED">;
+      TOTP_NOT_CONFIGURED: import("better-auth").RawError<"TOTP_NOT_CONFIGURED">;
+      TWO_FACTOR_NOT_ENABLED: import("better-auth").RawError<"TWO_FACTOR_NOT_ENABLED">;
+      BACKUP_CODES_NOT_ENABLED: import("better-auth").RawError<"BACKUP_CODES_NOT_ENABLED">;
+      INVALID_BACKUP_CODE: import("better-auth").RawError<"INVALID_BACKUP_CODE">;
+      INVALID_CODE: import("better-auth").RawError<"INVALID_CODE">;
+      TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+      ACCOUNT_TEMPORARILY_LOCKED: import("better-auth").RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
+      INVALID_TWO_FACTOR_COOKIE: import("better-auth").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+    };
+  }, {
+    id: "passkey";
+    version: string;
+    endpoints: {
+      generatePasskeyRegistrationOptions: import("better-auth").StrictEndpoint<"/passkey/generate-register-options", {
+        method: "GET";
+        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;
+            };
+          };
+        }>>[];
+        query: import("zod").ZodOptional<import("zod").ZodObject<{
+          authenticatorAttachment: import("zod").ZodOptional<import("zod").ZodEnum<{
+            platform: "platform";
+            "cross-platform": "cross-platform";
+          }>>;
+          name: import("zod").ZodOptional<import("zod").ZodString>;
+          context: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            parameters: import("better-auth").OpenAPIParameter[];
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        challenge: {
+                          type: string;
+                        };
+                        rp: {
+                          type: string;
+                          properties: {
+                            name: {
+                              type: string;
+                            };
+                            id: {
+                              type: string;
+                            };
+                          };
+                        };
+                        user: {
+                          type: string;
+                          properties: {
+                            id: {
+                              type: string;
+                            };
+                            name: {
+                              type: string;
+                            };
+                            displayName: {
+                              type: string;
+                            };
+                          };
+                        };
+                        pubKeyCredParams: {
+                          type: string;
+                          items: {
+                            type: string;
+                            properties: {
+                              type: {
+                                type: string;
+                              };
+                              alg: {
+                                type: string;
+                              };
+                            };
+                          };
+                        };
+                        timeout: {
+                          type: string;
+                        };
+                        excludeCredentials: {
+                          type: string;
+                          items: {
+                            type: string;
+                            properties: {
+                              id: {
+                                type: string;
+                              };
+                              type: {
+                                type: string;
+                              };
+                              transports: {
+                                type: string;
+                                items: {
+                                  type: string;
+                                };
+                              };
+                            };
+                          };
+                        };
+                        authenticatorSelection: {
+                          type: string;
+                          properties: {
+                            authenticatorAttachment: {
+                              type: string;
+                            };
+                            requireResidentKey: {
+                              type: string;
+                            };
+                            userVerification: {
+                              type: string;
+                            };
+                          };
+                        };
+                        attestation: {
+                          type: string;
+                        };
+                        extensions: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, import("@simplewebauthn/server").PublicKeyCredentialCreationOptionsJSON>;
+      generatePasskeyAuthenticationOptions: import("better-auth").StrictEndpoint<"/passkey/generate-authenticate-options", {
+        method: "GET";
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        challenge: {
+                          type: string;
+                        };
+                        rp: {
+                          type: string;
+                          properties: {
+                            name: {
+                              type: string;
+                            };
+                            id: {
+                              type: string;
+                            };
+                          };
+                        };
+                        user: {
+                          type: string;
+                          properties: {
+                            id: {
+                              type: string;
+                            };
+                            name: {
+                              type: string;
+                            };
+                            displayName: {
+                              type: string;
+                            };
+                          };
+                        };
+                        timeout: {
+                          type: string;
+                        };
+                        allowCredentials: {
+                          type: string;
+                          items: {
+                            type: string;
+                            properties: {
+                              id: {
+                                type: string;
+                              };
+                              type: {
+                                type: string;
+                              };
+                              transports: {
+                                type: string;
+                                items: {
+                                  type: string;
+                                };
+                              };
+                            };
+                          };
+                        };
+                        userVerification: {
+                          type: string;
+                        };
+                        authenticatorSelection: {
+                          type: string;
+                          properties: {
+                            authenticatorAttachment: {
+                              type: string;
+                            };
+                            requireResidentKey: {
+                              type: string;
+                            };
+                            userVerification: {
+                              type: string;
+                            };
+                          };
+                        };
+                        extensions: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, import("@simplewebauthn/server").PublicKeyCredentialRequestOptionsJSON>;
+      verifyPasskeyRegistration: import("better-auth").StrictEndpoint<"/passkey/verify-registration", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          response: import("zod").ZodAny;
+          name: import("zod").ZodOptional<import("zod").ZodString>;
+          createSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, 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: {
+            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: {
+                      readonly type: "object";
+                      readonly allOf: readonly [{
+                        readonly $ref: "#/components/schemas/Passkey";
+                      }, {
+                        readonly type: "object";
+                        readonly properties: {
+                          readonly session: {
+                            readonly $ref: "#/components/schemas/Session";
+                          };
+                          readonly user: {
+                            readonly $ref: "#/components/schemas/User";
+                          };
+                        };
+                      }];
+                    };
+                  };
+                };
+              };
+              400: {
+                description: string;
+              };
+            };
+          };
+        };
+      }, import("@better-auth/passkey").Passkey>;
+      verifyPasskeyAuthentication: import("better-auth").StrictEndpoint<"/passkey/verify-authentication", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          response: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        session: {
+                          $ref: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+          $Infer: {
+            body: {
+              response: import("@simplewebauthn/server").AuthenticationResponseJSON;
+            };
+          };
+        };
+      }, {
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+      }>;
+      listPasskeys: import("better-auth").StrictEndpoint<"/passkey/list-user-passkeys", {
+        method: "GET";
+        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: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "array";
+                      items: {
+                        $ref: string;
+                        required: string[];
+                      };
+                      description: string;
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, import("@better-auth/passkey").Passkey[]>;
+      deletePasskey: import("better-auth").StrictEndpoint<"/passkey/delete-passkey", {
+        method: "POST";
+        body: 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: {
+            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;
+            };
+          };
+        }>> | import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          verifiedResource: {};
+        }>>)[];
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        status: boolean;
+      }>;
+      updatePasskey: import("better-auth").StrictEndpoint<"/passkey/update-passkey", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          id: import("zod").ZodString;
+          name: 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: {
+            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;
+            };
+          };
+        }>> | import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+          verifiedResource: {};
+        }>>)[];
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        passkey: {
+                          $ref: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        passkey: import("@better-auth/passkey").Passkey;
+      }>;
+    };
+    schema: {
+      passkey: {
+        fields: {
+          name: {
+            type: "string";
+            required: false;
+          };
+          publicKey: {
+            type: "string";
+            required: true;
+          };
+          userId: {
+            type: "string";
+            references: {
+              model: string;
+              field: string;
+            };
+            required: true;
+            index: true;
+          };
+          credentialID: {
+            type: "string";
+            required: true;
+            index: true;
+          };
+          counter: {
+            type: "number";
+            required: true;
+          };
+          deviceType: {
+            type: "string";
+            required: true;
+          };
+          backedUp: {
+            type: "boolean";
+            required: true;
+          };
+          transports: {
+            type: "string";
+            required: false;
+          };
+          createdAt: {
+            type: "date";
+            required: false;
+          };
+          aaguid: {
+            type: "string";
+            required: false;
+          };
+        };
+      };
+    };
+    $ERROR_CODES: {
+      CHALLENGE_NOT_FOUND: import("better-auth").RawError<"CHALLENGE_NOT_FOUND">;
+      YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY">;
+      FAILED_TO_VERIFY_REGISTRATION: import("better-auth").RawError<"FAILED_TO_VERIFY_REGISTRATION">;
+      PASSKEY_NOT_FOUND: import("better-auth").RawError<"PASSKEY_NOT_FOUND">;
+      AUTHENTICATION_FAILED: import("better-auth").RawError<"AUTHENTICATION_FAILED">;
+      UNABLE_TO_CREATE_SESSION: import("better-auth").RawError<"UNABLE_TO_CREATE_SESSION">;
+      USER_NOT_FOUND: import("better-auth").RawError<"USER_NOT_FOUND">;
+      FAILED_TO_UPDATE_PASSKEY: import("better-auth").RawError<"FAILED_TO_UPDATE_PASSKEY">;
+      PREVIOUSLY_REGISTERED: import("better-auth").RawError<"PREVIOUSLY_REGISTERED">;
+      REGISTRATION_CANCELLED: import("better-auth").RawError<"REGISTRATION_CANCELLED">;
+      AUTH_CANCELLED: import("better-auth").RawError<"AUTH_CANCELLED">;
+      UNKNOWN_ERROR: import("better-auth").RawError<"UNKNOWN_ERROR">;
+      SESSION_REQUIRED: import("better-auth").RawError<"SESSION_REQUIRED">;
+      RESOLVE_USER_REQUIRED: import("better-auth").RawError<"RESOLVE_USER_REQUIRED">;
+      RESOLVED_USER_INVALID: import("better-auth").RawError<"RESOLVED_USER_INVALID">;
+    };
+    options: import("@better-auth/passkey").PasskeyOptions | undefined;
+  }, ...{
+    id: "email-otp";
+    version: string;
+    init(ctx: import("better-auth").AuthContext): {
+      options: {
+        emailVerification: {
+          sendVerificationEmail(data: {
+            user: import("better-auth").User;
+            url: string;
+            token: string;
+          }, request: Request | undefined): Promise<void>;
+        };
+      };
+    } | undefined;
+    endpoints: {
+      sendVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/send-verification-otp", {
+        method: "POST";
+        use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>[];
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          type: import("zod").ZodEnum<{
+            "sign-in": "sign-in";
+            "change-email": "change-email";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      createVerificationOTP: import("better-auth").StrictEndpoint<string, {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          type: import("zod").ZodEnum<{
+            "sign-in": "sign-in";
+            "change-email": "change-email";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "string";
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, string>;
+      getVerificationOTP: import("better-auth").StrictEndpoint<string, {
+        method: "GET";
+        query: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          type: import("zod").ZodEnum<{
+            "sign-in": "sign-in";
+            "change-email": "change-email";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        otp: {
+                          type: string;
+                          nullable: boolean;
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        otp: null;
+      } | {
+        otp: string;
+      }>;
+      checkVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/check-verification-otp", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          type: import("zod").ZodEnum<{
+            "sign-in": "sign-in";
+            "change-email": "change-email";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+          otp: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      verifyEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/verify-email", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          otp: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                          description: string;
+                          enum: boolean[];
+                        };
+                        token: {
+                          type: string;
+                          nullable: boolean;
+                          description: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        status: boolean;
+        token: string;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & Record<string, any>;
+      } | {
+        status: boolean;
+        token: null;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & Record<string, any>;
+      }>;
+      signInEmailOTP: import("better-auth").StrictEndpoint<"/sign-in/email-otp", {
+        method: "POST";
+        body: import("zod").ZodIntersection<import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          otp: import("zod").ZodString;
+          name: import("zod").ZodOptional<import("zod").ZodString>;
+          image: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        token: {
+                          type: string;
+                          description: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        token: string;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+      }>;
+      requestPasswordResetEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-password-reset", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                          description: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      forgetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/forget-password/email-otp", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                          description: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      resetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/reset-password", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          otp: import("zod").ZodString;
+          password: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      requestEmailChangeEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-email-change", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          newEmail: import("zod").ZodString;
+          otp: import("zod").ZodOptional<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: {
+            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: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      changeEmailEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/change-email", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          newEmail: import("zod").ZodString;
+          otp: 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: {
+            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: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+    };
+    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>>;
+      }[];
+    };
+    rateLimit: ({
+      pathMatcher(path: string): path is "/email-otp/send-verification-otp";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/email-otp/check-verification-otp";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/email-otp/verify-email";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/sign-in/email-otp";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/email-otp/request-password-reset";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/email-otp/reset-password";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/forget-password/email-otp";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/email-otp/request-email-change";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/email-otp/change-email";
+      window: number;
+      max: number;
+    })[];
+    options: import("better-auth/plugins").EmailOTPOptions;
+    $ERROR_CODES: {
+      OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+      INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+      TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+    };
+  }[], {
+    id: "protobase-sign-in-policy";
+    schema: {
+      readonly signInPolicy: {
+        readonly fields: {
+          readonly password: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly emailCode: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly passkey: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly twoFactor: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly staffAccess: {
+            readonly type: "string";
+            readonly required: true;
+            readonly defaultValue: "allowed";
+          };
+          readonly createdAt: {
+            readonly type: "date";
+            readonly required: true;
+          };
+          readonly createdBy: {
+            readonly type: "string";
+            readonly required: false;
+          };
+        };
+      };
+    };
+    endpoints: {
+      getSignInPolicy: import("better-auth").StrictEndpoint<"/policy/sign-in", {
+        method: "GET";
+        use: import("better-auth").Middleware<{
+          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;
+              };
+            };
+          }>>[];
+        }, (inputContext: import("better-auth").MiddlewareInputContext<{
+          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;
+              };
+            };
+          }>>[];
+        }>) => 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;
+            };
+          } & {
+            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>;
+          };
+        }>>[];
+      }, {
+        savedBy?: string | undefined;
+        savedAt?: string | undefined;
+        operator?: string | undefined;
+        policy: SignInPolicy;
+        effective: SignInPolicy;
+        mail: boolean;
+      }>;
+      setSignInPolicy: import("better-auth").StrictEndpoint<"/policy/sign-in", {
+        method: "POST";
+        use: import("better-auth").Middleware<{
+          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;
+              };
+            };
+          }>>[];
+        }, (inputContext: import("better-auth").MiddlewareInputContext<{
+          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;
+              };
+            };
+          }>>[];
+        }>) => 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;
+            };
+          } & {
+            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>;
+          };
+        }>>[];
+        body: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+      }, {
+        savedBy?: string | undefined;
+        savedAt?: string | undefined;
+        operator?: string | undefined;
+        policy: SignInPolicy;
+        effective: SignInPolicy;
+        mail: boolean;
+      }>;
+      getSignInMethods: import("better-auth").StrictEndpoint<"/account/sign-in-methods", {
+        method: "GET";
+        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;
+            };
+          };
+        }>>[];
+      }, {
+        policy: SignInPolicy;
+        mail: boolean;
+        account: {
+          password: boolean;
+          passkeys: number;
+          twoFactor: boolean;
+          authenticatorApp: boolean;
+        };
+        missing: ("passkey" | "twoFactor")[];
+      }>;
+    };
+    hooks: {
+      before: {
+        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>>;
+      }[];
+    };
+  }, {
+    id: "protobase-staff-sign-in";
+    schema: {
+      readonly staffSignIn: {
+        readonly fields: {
+          readonly userId: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly userEmail: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly staff: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly staffName: {
+            readonly type: "string";
+            readonly required: false;
+          };
+          readonly staffSubject: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly issuer: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly reason: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly sessionId: {
+            readonly type: "string";
+            readonly required: true;
+          };
+          readonly startedAt: {
+            readonly type: "date";
+            readonly required: true;
+          };
+          readonly expiresAt: {
+            readonly type: "date";
+            readonly required: true;
+          };
+          readonly endedAt: {
+            readonly type: "date";
+            readonly required: false;
+          };
+        };
+      };
+    };
+    endpoints: {
+      getStaffSession: import("better-auth").StrictEndpoint<"/staff/session", {
+        method: "GET";
+        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;
+            };
+          };
+        }>>[];
+      }, {
+        staff: StaffSignIn | null;
+      }>;
+      stopStaffSession: import("better-auth").StrictEndpoint<"/staff/stop", {
+        method: "POST";
+        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;
+            };
+          };
+        }>>[];
+      }, {
+        stopped: boolean;
+      }>;
+      listStaffSignIns: import("better-auth").StrictEndpoint<"/staff/sign-ins", {
+        method: "GET";
+        use: import("better-auth").Middleware<{
+          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;
+              };
+            };
+          }>>[];
+        }, (inputContext: import("better-auth").MiddlewareInputContext<{
+          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;
+              };
+            };
+          }>>[];
+        }>) => 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;
+            };
+          } & {
+            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>;
+          };
+        }>>[];
+      }, {
+        signIns: StaffSignIn[];
+      }>;
+      startStaffSignIn?: import("better-auth").StrictEndpoint<"/staff/sign-in", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodEmail;
+          reason: import("zod").ZodString;
+          callbackURL: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+      }, {
+        url: string;
+      }> | undefined;
+      staffCallback?: import("better-auth").StrictEndpoint<"/staff/callback", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+          state: import("zod").ZodOptional<import("zod").ZodString>;
+          code: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+      }, never> | undefined;
+    };
+    hooks: {
+      before: {
+        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>>;
+      }[];
+    };
+  }];
+  disabledPaths: string[];
+  databaseHooks: {
+    user: {
+      create: {
+        after?: ((user: import("better-auth").User & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null) => Promise<void>) | undefined;
+        before: (user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null) => 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;
+      };
+      '/staff/sign-in': {
         window: number;
         max: number;
       };
@@ -1236,6 +3560,7 @@ export declare const createAuth: (options: CreateAuthOptions) => import("better-
     encryptOAuthTokens: true;
   } | undefined;
   socialProviders?: import("better-auth").SocialProviders | undefined;
+  appName: string;
   database: any;
   baseURL: string;
   basePath: string;
@@ -1256,8 +3581,10 @@ export declare const createAuth: (options: CreateAuthOptions) => import("better-
 }> & {
   roles: string[];
   defaultRole: string | undefined;
+  mail: boolean;
   passwordReset: boolean;
   socialProviders: string[];
+  operator: string | undefined;
 };
 export type AdminAuth = ReturnType<typeof createAuth>;
 //#endregion