@tulip-systems/core 0.8.2 → 0.9.0

package/dist/src/modules/auth/handler/service.server.d.mts

@@ -0,0 +1,2101 @@
+import { Role as Role$1, createAccessControl } from "../lib/permissions.mjs";
+import { TDatabaseSchema } from "../../database/lib/types.mjs";
+import { Database } from "../../database/lib/service.server.mjs";
+import { TulipConfig } from "../../config/lib/config.mjs";
+import { Email } from "../../emails/lib/service.server.mjs";
+import "../../../../config.mjs";
+import * as zod from "zod";
+import * as _better_auth_passkey_client0 from "@better-auth/passkey/client";
+import * as _better_auth_passkey0 from "@better-auth/passkey";
+import * as better_auth_plugins0 from "better-auth/plugins";
+import * as better_auth0 from "better-auth";
+import * as better_call0 from "better-call";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/modules/auth/handler/service.server.d.ts
+declare const authCookiePrefix = "tulip";
+type InitAuthProps<TSchema extends TDatabaseSchema> = {
+  db: Database<TSchema>;
+  email: Email;
+  config: TulipConfig;
+  ac: ReturnType<typeof createAccessControl>;
+  roles: { [key in string]?: Role$1 };
+  allowedHosts: string[];
+  defaultRole?: string;
+};
+/**
+ * Create the Better Auth server instance.
+ */
+declare function createAuth<TSchema extends TDatabaseSchema>(props: InitAuthProps<TSchema>): better_auth0.Auth<{
+  advanced: {
+    cookiePrefix: string;
+    database: {
+      generateId: () => false;
+    };
+  };
+  baseURL: {
+    allowedHosts: string[];
+  };
+  database: (options: better_auth0.BetterAuthOptions) => better_auth0.DBAdapter<better_auth0.BetterAuthOptions>;
+  emailAndPassword: {
+    enabled: true;
+  };
+  user: {
+    changeEmail: {
+      enabled: true;
+    };
+    additionalFields: {
+      firstName: {
+        type: "string";
+        required: true;
+        input: true;
+      };
+      lastName: {
+        type: "string";
+        required: true;
+        input: true;
+      };
+    };
+  };
+  hooks: {
+    after: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+  };
+  plugins: [{
+    id: "passkey";
+    version: string;
+    endpoints: {
+      generatePasskeyRegistrationOptions: better_call0.StrictEndpoint<"/passkey/generate-register-options", {
+        method: "GET";
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        query: zod.ZodOptional<zod.ZodObject<{
+          authenticatorAttachment: zod.ZodOptional<zod.ZodEnum<{
+            platform: "platform";
+            "cross-platform": "cross-platform";
+          }>>;
+          name: zod.ZodOptional<zod.ZodString>;
+          context: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core0.$strip>>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                parameters: {
+                  query: {
+                    authenticatorAttachment: {
+                      description: string;
+                      required: boolean;
+                    };
+                    name: {
+                      description: string;
+                      required: boolean;
+                    };
+                    context: {
+                      description: string;
+                      required: boolean;
+                    };
+                  };
+                };
+                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;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, _better_auth_passkey_client0.PublicKeyCredentialCreationOptionsJSON>;
+      generatePasskeyAuthenticationOptions: better_call0.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;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, _better_auth_passkey_client0.PublicKeyCredentialRequestOptionsJSON>;
+      verifyPasskeyRegistration: better_call0.StrictEndpoint<"/passkey/verify-registration", {
+        method: "POST";
+        body: zod.ZodObject<{
+          response: zod.ZodAny;
+          name: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      $ref: string;
+                    };
+                  };
+                };
+              };
+              400: {
+                description: string;
+              };
+            };
+          };
+        };
+      }, _better_auth_passkey0.Passkey>;
+      verifyPasskeyAuthentication: better_call0.StrictEndpoint<"/passkey/verify-authentication", {
+        method: "POST";
+        body: zod.ZodObject<{
+          response: zod.ZodRecord<zod.ZodAny, zod.ZodAny>;
+        }, zod_v4_core0.$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: _better_auth_passkey_client0.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: better_call0.StrictEndpoint<"/passkey/list-user-passkeys", {
+        method: "GET";
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "array";
+                      items: {
+                        $ref: string;
+                        required: string[];
+                      };
+                      description: string;
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, _better_auth_passkey0.Passkey[]>;
+      deletePasskey: better_call0.StrictEndpoint<"/passkey/delete-passkey", {
+        method: "POST";
+        body: zod.ZodObject<{
+          id: zod.ZodString;
+        }, zod_v4_core0.$strip>;
+        use: (((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>) | ((inputContext: better_call0.MiddlewareInputContext<better_call0.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: better_call0.StrictEndpoint<"/passkey/update-passkey", {
+        method: "POST";
+        body: zod.ZodObject<{
+          id: zod.ZodString;
+          name: zod.ZodString;
+        }, zod_v4_core0.$strip>;
+        use: (((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>) | ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          verifiedResource: {};
+        }>))[];
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        passkey: {
+                          $ref: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        passkey: _better_auth_passkey0.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: better_auth0.RawError<"CHALLENGE_NOT_FOUND">;
+      YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY">;
+      FAILED_TO_VERIFY_REGISTRATION: better_auth0.RawError<"FAILED_TO_VERIFY_REGISTRATION">;
+      PASSKEY_NOT_FOUND: better_auth0.RawError<"PASSKEY_NOT_FOUND">;
+      AUTHENTICATION_FAILED: better_auth0.RawError<"AUTHENTICATION_FAILED">;
+      UNABLE_TO_CREATE_SESSION: better_auth0.RawError<"UNABLE_TO_CREATE_SESSION">;
+      FAILED_TO_UPDATE_PASSKEY: better_auth0.RawError<"FAILED_TO_UPDATE_PASSKEY">;
+      PREVIOUSLY_REGISTERED: better_auth0.RawError<"PREVIOUSLY_REGISTERED">;
+      REGISTRATION_CANCELLED: better_auth0.RawError<"REGISTRATION_CANCELLED">;
+      AUTH_CANCELLED: better_auth0.RawError<"AUTH_CANCELLED">;
+      UNKNOWN_ERROR: better_auth0.RawError<"UNKNOWN_ERROR">;
+      SESSION_REQUIRED: better_auth0.RawError<"SESSION_REQUIRED">;
+      RESOLVE_USER_REQUIRED: better_auth0.RawError<"RESOLVE_USER_REQUIRED">;
+      RESOLVED_USER_INVALID: better_auth0.RawError<"RESOLVED_USER_INVALID">;
+    };
+    options: _better_auth_passkey0.PasskeyOptions | undefined;
+  }, {
+    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: better_auth0.GenericEndpointContext | null): Promise<void>;
+            };
+          };
+        };
+      };
+    };
+    hooks: {
+      after: {
+        matcher(context: better_auth0.HookEndpointContext): boolean;
+        handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<better_auth_plugins0.SessionWithImpersonatedBy[] | undefined>;
+      }[];
+    };
+    endpoints: {
+      setRole: better_call0.StrictEndpoint<"/admin/set-role", {
+        method: "POST";
+        body: zod.ZodObject<{
+          userId: zod.ZodCoercedString<unknown>;
+          role: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodString>]>;
+        }, zod_v4_core0.$strip>;
+        requireHeaders: true;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+          $Infer: {
+            body: {
+              userId: string;
+              role: string | string[];
+            };
+          };
+        };
+      }, {
+        user: better_auth_plugins0.UserWithRole;
+      }>;
+      getUser: better_call0.StrictEndpoint<"/admin/get-user", {
+        method: "GET";
+        query: zod.ZodObject<{
+          id: zod.ZodString;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, better_auth_plugins0.UserWithRole>;
+      createUser: better_call0.StrictEndpoint<"/admin/create-user", {
+        method: "POST";
+        body: zod.ZodObject<{
+          email: zod.ZodString;
+          password: zod.ZodOptional<zod.ZodString>;
+          name: zod.ZodString;
+          role: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodString>]>>;
+          data: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
+        }, zod_v4_core0.$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 | string[] | undefined;
+              data?: Record<string, any> | undefined;
+            };
+          };
+        };
+      }, {
+        user: better_auth_plugins0.UserWithRole;
+      }>;
+      adminUpdateUser: better_call0.StrictEndpoint<"/admin/update-user", {
+        method: "POST";
+        body: zod.ZodObject<{
+          userId: zod.ZodCoercedString<unknown>;
+          data: zod.ZodRecord<zod.ZodAny, zod.ZodAny>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, better_auth_plugins0.UserWithRole>;
+      listUsers: better_call0.StrictEndpoint<"/admin/list-users", {
+        method: "GET";
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        query: zod.ZodObject<{
+          searchValue: zod.ZodOptional<zod.ZodString>;
+          searchField: zod.ZodOptional<zod.ZodEnum<{
+            email: "email";
+            name: "name";
+          }>>;
+          searchOperator: zod.ZodOptional<zod.ZodEnum<{
+            contains: "contains";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+          }>>;
+          limit: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>>;
+          offset: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>>;
+          sortBy: zod.ZodOptional<zod.ZodString>;
+          sortDirection: zod.ZodOptional<zod.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+          }>>;
+          filterField: zod.ZodOptional<zod.ZodString>;
+          filterValue: zod.ZodOptional<zod.ZodUnion<[zod.ZodUnion<[zod.ZodUnion<[zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, zod.ZodBoolean]>, zod.ZodArray<zod.ZodString>]>, zod.ZodArray<zod.ZodNumber>]>>;
+          filterOperator: zod.ZodOptional<zod.ZodEnum<{
+            eq: "eq";
+            ne: "ne";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            in: "in";
+            not_in: "not_in";
+            contains: "contains";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+          }>>;
+        }, zod_v4_core0.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        users: {
+                          type: string;
+                          items: {
+                            $ref: string;
+                          };
+                        };
+                        total: {
+                          type: string;
+                        };
+                        limit: {
+                          type: string;
+                        };
+                        offset: {
+                          type: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        users: better_auth_plugins0.UserWithRole[];
+        total: number;
+      }>;
+      listUserSessions: better_call0.StrictEndpoint<"/admin/list-user-sessions", {
+        method: "POST";
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        body: zod.ZodObject<{
+          userId: zod.ZodCoercedString<unknown>;
+        }, zod_v4_core0.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        sessions: {
+                          type: string;
+                          items: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        sessions: better_auth_plugins0.SessionWithImpersonatedBy[];
+      }>;
+      unbanUser: better_call0.StrictEndpoint<"/admin/unban-user", {
+        method: "POST";
+        body: zod.ZodObject<{
+          userId: zod.ZodCoercedString<unknown>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        user: better_auth_plugins0.UserWithRole;
+      }>;
+      banUser: better_call0.StrictEndpoint<"/admin/ban-user", {
+        method: "POST";
+        body: zod.ZodObject<{
+          userId: zod.ZodCoercedString<unknown>;
+          banReason: zod.ZodOptional<zod.ZodString>;
+          banExpiresIn: zod.ZodOptional<zod.ZodNumber>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        user: better_auth_plugins0.UserWithRole;
+      }>;
+      impersonateUser: better_call0.StrictEndpoint<"/admin/impersonate-user", {
+        method: "POST";
+        body: zod.ZodObject<{
+          userId: zod.ZodCoercedString<unknown>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        session: {
+                          $ref: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+        user: better_auth_plugins0.UserWithRole;
+      }>;
+      stopImpersonating: better_call0.StrictEndpoint<"/admin/stop-impersonating", {
+        method: "POST";
+        requireHeaders: true;
+      }, {
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        } & Record<string, any>;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & Record<string, any>;
+      }>;
+      revokeUserSession: better_call0.StrictEndpoint<"/admin/revoke-user-session", {
+        method: "POST";
+        body: zod.ZodObject<{
+          sessionToken: zod.ZodString;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      revokeUserSessions: better_call0.StrictEndpoint<"/admin/revoke-user-sessions", {
+        method: "POST";
+        body: zod.ZodObject<{
+          userId: zod.ZodCoercedString<unknown>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      removeUser: better_call0.StrictEndpoint<"/admin/remove-user", {
+        method: "POST";
+        body: zod.ZodObject<{
+          userId: zod.ZodCoercedString<unknown>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      setUserPassword: better_call0.StrictEndpoint<"/admin/set-user-password", {
+        method: "POST";
+        body: zod.ZodObject<{
+          newPassword: zod.ZodString;
+          userId: zod.ZodCoercedString<unknown>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_plugins0.UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        status: boolean;
+      }>;
+      userHasPermission: better_call0.StrictEndpoint<"/admin/has-permission", {
+        method: "POST";
+        body: zod.ZodIntersection<zod.ZodObject<{
+          userId: zod.ZodOptional<zod.ZodCoercedString<unknown>>;
+          role: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core0.$strip>, zod.ZodXor<readonly [zod.ZodObject<{
+          permission: zod.ZodRecord<zod.ZodString, zod.ZodArray<zod.ZodString>>;
+        }, zod_v4_core0.$strip>, zod.ZodObject<{
+          permissions: zod.ZodRecord<zod.ZodString, zod.ZodArray<zod.ZodString>>;
+        }, zod_v4_core0.$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 [x: string]: better_auth0.LiteralString[] | undefined;
+              };
+            } & {
+              userId?: string | undefined;
+              role?: string | undefined;
+            };
+          };
+        };
+      }, {
+        error: null;
+        success: boolean;
+      }>;
+    };
+    $ERROR_CODES: {
+      USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: better_auth0.RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+      FAILED_TO_CREATE_USER: better_auth0.RawError<"FAILED_TO_CREATE_USER">;
+      USER_ALREADY_EXISTS: better_auth0.RawError<"USER_ALREADY_EXISTS">;
+      YOU_CANNOT_BAN_YOURSELF: better_auth0.RawError<"YOU_CANNOT_BAN_YOURSELF">;
+      YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+      YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+      YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+      YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+      BANNED_USER: better_auth0.RawError<"BANNED_USER">;
+      YOU_ARE_NOT_ALLOWED_TO_GET_USER: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+      NO_DATA_TO_UPDATE: better_auth0.RawError<"NO_DATA_TO_UPDATE">;
+      YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+      YOU_CANNOT_REMOVE_YOURSELF: better_auth0.RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+      YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+      YOU_CANNOT_IMPERSONATE_ADMINS: better_auth0.RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+      INVALID_ROLE_TYPE: better_auth0.RawError<"INVALID_ROLE_TYPE">;
+    };
+    schema: {
+      user: {
+        fields: {
+          role: {
+            type: "string";
+            required: false;
+            input: false;
+          };
+          banned: {
+            type: "boolean";
+            defaultValue: false;
+            required: false;
+            input: false;
+          };
+          banReason: {
+            type: "string";
+            required: false;
+            input: false;
+          };
+          banExpires: {
+            type: "date";
+            required: false;
+            input: false;
+          };
+        };
+      };
+      session: {
+        fields: {
+          impersonatedBy: {
+            type: "string";
+            required: false;
+          };
+        };
+      };
+    };
+    options: NoInfer<{
+      roles: {
+        [x: string]: Role$1 | undefined;
+      };
+      ac: {
+        newRole<K extends string | number>(statements: better_auth_plugins0.Subset<K, better_auth_plugins0.Statements>): {
+          authorize<K_1 extends K>(request: K_1 extends infer T extends K_2 ? { [key in T]?: better_auth_plugins0.Subset<K, better_auth_plugins0.Statements>[key] | {
+            actions: better_auth_plugins0.Subset<K, better_auth_plugins0.Statements>[key];
+            connector: "OR" | "AND";
+          } | undefined } : never, connector?: "OR" | "AND"): better_auth_plugins0.AuthorizeResponse;
+          statements: better_auth_plugins0.Subset<K, better_auth_plugins0.Statements>;
+        };
+        statements: better_auth_plugins0.Statements;
+      };
+      adminRoles: string[];
+      defaultRole: string;
+    }>;
+  }, {
+    id: "email-otp";
+    version: string;
+    init(ctx: better_auth0.AuthContext): {
+      options: {
+        emailVerification: {
+          sendVerificationEmail(data: {
+            user: better_auth0.User;
+            url: string;
+            token: string;
+          }, request: Request | undefined): Promise<void>;
+        };
+      };
+    } | undefined;
+    endpoints: {
+      sendVerificationOTP: better_call0.StrictEndpoint<"/email-otp/send-verification-otp", {
+        method: "POST";
+        body: zod.ZodObject<{
+          email: zod.ZodString;
+          type: zod.ZodEnum<{
+            "sign-in": "sign-in";
+            "change-email": "change-email";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, zod_v4_core0.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      createVerificationOTP: better_call0.StrictEndpoint<string, {
+        method: "POST";
+        body: zod.ZodObject<{
+          email: zod.ZodString;
+          type: zod.ZodEnum<{
+            "sign-in": "sign-in";
+            "change-email": "change-email";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, zod_v4_core0.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "string";
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, string>;
+      getVerificationOTP: better_call0.StrictEndpoint<string, {
+        method: "GET";
+        query: zod.ZodObject<{
+          email: zod.ZodString;
+          type: zod.ZodEnum<{
+            "sign-in": "sign-in";
+            "change-email": "change-email";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, zod_v4_core0.$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: better_call0.StrictEndpoint<"/email-otp/check-verification-otp", {
+        method: "POST";
+        body: zod.ZodObject<{
+          email: zod.ZodString;
+          type: zod.ZodEnum<{
+            "sign-in": "sign-in";
+            "change-email": "change-email";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+          otp: zod.ZodString;
+        }, zod_v4_core0.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      verifyEmailOTP: better_call0.StrictEndpoint<"/email-otp/verify-email", {
+        method: "POST";
+        body: zod.ZodObject<{
+          email: zod.ZodString;
+          otp: zod.ZodString;
+        }, zod_v4_core0.$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: better_call0.StrictEndpoint<"/sign-in/email-otp", {
+        method: "POST";
+        body: zod.ZodIntersection<zod.ZodObject<{
+          email: zod.ZodString;
+          otp: zod.ZodString;
+          name: zod.ZodOptional<zod.ZodString>;
+          image: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core0.$strip>, zod.ZodRecord<zod.ZodString, 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: better_call0.StrictEndpoint<"/email-otp/request-password-reset", {
+        method: "POST";
+        body: zod.ZodObject<{
+          email: zod.ZodString;
+        }, zod_v4_core0.$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: better_call0.StrictEndpoint<"/forget-password/email-otp", {
+        method: "POST";
+        body: zod.ZodObject<{
+          email: zod.ZodString;
+        }, zod_v4_core0.$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: better_call0.StrictEndpoint<"/email-otp/reset-password", {
+        method: "POST";
+        body: zod.ZodObject<{
+          email: zod.ZodString;
+          otp: zod.ZodString;
+          password: zod.ZodString;
+        }, zod_v4_core0.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      requestEmailChangeEmailOTP: better_call0.StrictEndpoint<"/email-otp/request-email-change", {
+        method: "POST";
+        body: zod.ZodObject<{
+          newEmail: zod.ZodString;
+          otp: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      changeEmailEmailOTP: better_call0.StrictEndpoint<"/email-otp/change-email", {
+        method: "POST";
+        body: zod.ZodObject<{
+          newEmail: zod.ZodString;
+          otp: zod.ZodString;
+        }, zod_v4_core0.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+    };
+    hooks: {
+      after: {
+        matcher(context: better_auth0.HookEndpointContext): boolean;
+        handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.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: better_auth_plugins0.EmailOTPOptions;
+    $ERROR_CODES: {
+      OTP_EXPIRED: better_auth0.RawError<"OTP_EXPIRED">;
+      INVALID_OTP: better_auth0.RawError<"INVALID_OTP">;
+      TOO_MANY_ATTEMPTS: better_auth0.RawError<"TOO_MANY_ATTEMPTS">;
+    };
+  }];
+}>;
+/**
+ * Better Auth instance type returned by `Auth.init()`.
+ */
+type Auth = ReturnType<typeof createAuth>;
+/**
+ * Auth service namespace.
+ *
+ * @example
+ * const auth = Auth.init({ db, email, config, ac, roles, allowedHosts });
+ */
+declare const Auth: {
+  init: typeof createAuth;
+};
+//#endregion
+export { Auth, authCookiePrefix };