better-auth 1.6.27 → 1.6.28

package/dist/plugins/phone-number/index.d.mts

@@ -1,4 +1,10 @@
 import { PhoneNumberOptions, UserWithPhoneNumber } from "./types.mjs";
+import * as _$_better_auth_core0 from "@better-auth/core";
+import * as _$_better_auth_core_utils_error_codes0 from "@better-auth/core/utils/error-codes";
+import * as _$better_call0 from "better-call";
+import * as _$zod from "zod";
+import * as _$zod_v4_core0 from "zod/v4/core";
+
 //#region src/plugins/phone-number/index.d.ts
 declare module "@better-auth/core" {
   interface BetterAuthPluginRegistry<AuthOptions, Options> {
@@ -42,18 +48,18 @@ declare const phoneNumber: (options?: PhoneNumberOptions | undefined) => {
   };
   hooks: {
     before: {
-      matcher: (ctx: import("@better-auth/core").HookEndpointContext) => boolean;
-      handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<never>>;
+      matcher: (ctx: _$_better_auth_core0.HookEndpointContext) => boolean;
+      handler: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<never>>;
     }[];
   };
   endpoints: {
-    signInPhoneNumber: import("better-call").StrictEndpoint<"/sign-in/phone-number", {
+    signInPhoneNumber: _$better_call0.StrictEndpoint<"/sign-in/phone-number", {
       method: "POST";
-      body: import("zod").ZodObject<{
-        phoneNumber: import("zod").ZodString;
-        password: import("zod").ZodString;
-        rememberMe: import("zod").ZodOptional<import("zod").ZodBoolean>;
-      }, import("zod/v4/core").$strip>;
+      body: _$zod.ZodObject<{
+        phoneNumber: _$zod.ZodString;
+        password: _$zod.ZodString;
+        rememberMe: _$zod.ZodOptional<_$zod.ZodBoolean>;
+      }, _$zod_v4_core0.$strip>;
       metadata: {
         openapi: {
           summary: string;
@@ -87,11 +93,11 @@ declare const phoneNumber: (options?: PhoneNumberOptions | undefined) => {
       token: string;
       user: UserWithPhoneNumber;
     }>;
-    sendPhoneNumberOTP: import("better-call").StrictEndpoint<"/phone-number/send-otp", {
+    sendPhoneNumberOTP: _$better_call0.StrictEndpoint<"/phone-number/send-otp", {
       method: "POST";
-      body: import("zod").ZodObject<{
-        phoneNumber: import("zod").ZodString;
-      }, import("zod/v4/core").$strip>;
+      body: _$zod.ZodObject<{
+        phoneNumber: _$zod.ZodString;
+      }, _$zod_v4_core0.$strip>;
       metadata: {
         openapi: {
           summary: string;
@@ -118,14 +124,14 @@ declare const phoneNumber: (options?: PhoneNumberOptions | undefined) => {
     }, {
       message: string;
     }>;
-    verifyPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/verify", {
+    verifyPhoneNumber: _$better_call0.StrictEndpoint<"/phone-number/verify", {
       method: "POST";
-      body: import("zod").ZodIntersection<import("zod").ZodObject<{
-        phoneNumber: import("zod").ZodString;
-        code: import("zod").ZodString;
-        disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        updatePhoneNumber: import("zod").ZodOptional<import("zod").ZodBoolean>;
-      }, import("zod/v4/core").$strip>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+      body: _$zod.ZodIntersection<_$zod.ZodObject<{
+        phoneNumber: _$zod.ZodString;
+        code: _$zod.ZodString;
+        disableSession: _$zod.ZodOptional<_$zod.ZodBoolean>;
+        updatePhoneNumber: _$zod.ZodOptional<_$zod.ZodBoolean>;
+      }, _$zod_v4_core0.$strip>, _$zod.ZodRecord<_$zod.ZodString, _$zod.ZodAny>>;
       metadata: {
         openapi: {
           summary: string;
@@ -229,11 +235,11 @@ declare const phoneNumber: (options?: PhoneNumberOptions | undefined) => {
       token: null;
       user: UserWithPhoneNumber;
     }>;
-    requestPasswordResetPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/request-password-reset", {
+    requestPasswordResetPhoneNumber: _$better_call0.StrictEndpoint<"/phone-number/request-password-reset", {
       method: "POST";
-      body: import("zod").ZodObject<{
-        phoneNumber: import("zod").ZodString;
-      }, import("zod/v4/core").$strip>;
+      body: _$zod.ZodObject<{
+        phoneNumber: _$zod.ZodString;
+      }, _$zod_v4_core0.$strip>;
       metadata: {
         openapi: {
           description: string;
@@ -262,13 +268,13 @@ declare const phoneNumber: (options?: PhoneNumberOptions | undefined) => {
     }, {
       status: boolean;
     }>;
-    resetPasswordPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/reset-password", {
+    resetPasswordPhoneNumber: _$better_call0.StrictEndpoint<"/phone-number/reset-password", {
       method: "POST";
-      body: import("zod").ZodObject<{
-        otp: import("zod").ZodString;
-        phoneNumber: import("zod").ZodString;
-        newPassword: import("zod").ZodString;
-      }, import("zod/v4/core").$strip>;
+      body: _$zod.ZodObject<{
+        otp: _$zod.ZodString;
+        phoneNumber: _$zod.ZodString;
+        newPassword: _$zod.ZodString;
+      }, _$zod_v4_core0.$strip>;
       metadata: {
         openapi: {
           description: string;
@@ -324,18 +330,18 @@ declare const phoneNumber: (options?: PhoneNumberOptions | undefined) => {
   }[];
   options: PhoneNumberOptions | undefined;
   $ERROR_CODES: {
-    OTP_EXPIRED: import("@better-auth/core/utils/error-codes").RawError<"OTP_EXPIRED">;
-    INVALID_OTP: import("@better-auth/core/utils/error-codes").RawError<"INVALID_OTP">;
-    TOO_MANY_ATTEMPTS: import("@better-auth/core/utils/error-codes").RawError<"TOO_MANY_ATTEMPTS">;
-    INVALID_PHONE_NUMBER: import("@better-auth/core/utils/error-codes").RawError<"INVALID_PHONE_NUMBER">;
-    PHONE_NUMBER_EXIST: import("@better-auth/core/utils/error-codes").RawError<"PHONE_NUMBER_EXIST">;
-    PHONE_NUMBER_NOT_EXIST: import("@better-auth/core/utils/error-codes").RawError<"PHONE_NUMBER_NOT_EXIST">;
-    INVALID_PHONE_NUMBER_OR_PASSWORD: import("@better-auth/core/utils/error-codes").RawError<"INVALID_PHONE_NUMBER_OR_PASSWORD">;
-    UNEXPECTED_ERROR: import("@better-auth/core/utils/error-codes").RawError<"UNEXPECTED_ERROR">;
-    OTP_NOT_FOUND: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_FOUND">;
-    PHONE_NUMBER_NOT_VERIFIED: import("@better-auth/core/utils/error-codes").RawError<"PHONE_NUMBER_NOT_VERIFIED">;
-    PHONE_NUMBER_CANNOT_BE_UPDATED: import("@better-auth/core/utils/error-codes").RawError<"PHONE_NUMBER_CANNOT_BE_UPDATED">;
-    SEND_OTP_NOT_IMPLEMENTED: import("@better-auth/core/utils/error-codes").RawError<"SEND_OTP_NOT_IMPLEMENTED">;
+    OTP_EXPIRED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_EXPIRED">;
+    INVALID_OTP: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_OTP">;
+    TOO_MANY_ATTEMPTS: _$_better_auth_core_utils_error_codes0.RawError<"TOO_MANY_ATTEMPTS">;
+    INVALID_PHONE_NUMBER: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_PHONE_NUMBER">;
+    PHONE_NUMBER_EXIST: _$_better_auth_core_utils_error_codes0.RawError<"PHONE_NUMBER_EXIST">;
+    PHONE_NUMBER_NOT_EXIST: _$_better_auth_core_utils_error_codes0.RawError<"PHONE_NUMBER_NOT_EXIST">;
+    INVALID_PHONE_NUMBER_OR_PASSWORD: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_PHONE_NUMBER_OR_PASSWORD">;
+    UNEXPECTED_ERROR: _$_better_auth_core_utils_error_codes0.RawError<"UNEXPECTED_ERROR">;
+    OTP_NOT_FOUND: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_FOUND">;
+    PHONE_NUMBER_NOT_VERIFIED: _$_better_auth_core_utils_error_codes0.RawError<"PHONE_NUMBER_NOT_VERIFIED">;
+    PHONE_NUMBER_CANNOT_BE_UPDATED: _$_better_auth_core_utils_error_codes0.RawError<"PHONE_NUMBER_CANNOT_BE_UPDATED">;
+    SEND_OTP_NOT_IMPLEMENTED: _$_better_auth_core_utils_error_codes0.RawError<"SEND_OTP_NOT_IMPLEMENTED">;
   };
 };
 //#endregion

package/dist/plugins/phone-number/types.d.mts

@@ -1,8 +1,8 @@
 import { User } from "../../types/models.mjs";
 import { InferOptionSchema } from "../../types/plugins.mjs";
-import "../../types/index.mjs";
 import { schema } from "./schema.mjs";
 import { Awaitable, GenericEndpointContext } from "@better-auth/core";
+
 //#region src/plugins/phone-number/types.d.ts
 interface UserWithPhoneNumber extends User {
   phoneNumber: string;

package/dist/plugins/siwe/client.d.mts

@@ -1,4 +1,5 @@
 import { siwe } from "./index.mjs";
+
 //#region src/plugins/siwe/client.d.ts
 declare const siweClient: () => {
   id: "siwe";

package/dist/plugins/siwe/index.d.mts

@@ -1,8 +1,9 @@
 import { InferOptionSchema } from "../../types/plugins.mjs";
-import "../../types/index.mjs";
 import { WalletAddressSchema, schema } from "./schema.mjs";
 import { ENSLookupArgs, ENSLookupResult, SIWEVerifyMessageArgs } from "./types.mjs";
+import * as _$better_call0 from "better-call";
 import * as z from "zod";
+
 //#region src/plugins/siwe/index.d.ts
 declare module "@better-auth/core" {
   interface BetterAuthPluginRegistry<AuthOptions, Options> {
@@ -25,7 +26,7 @@ declare const siwe: (options: SIWEPluginOptions) => {
   version: string;
   schema: WalletAddressSchema;
   endpoints: {
-    getSiweNonce: import("better-call").StrictEndpoint<"/siwe/nonce" | "/siwe/get-nonce", {
+    getSiweNonce: _$better_call0.StrictEndpoint<"/siwe/nonce" | "/siwe/get-nonce", {
       method: "POST";
       body: z.ZodObject<{
         walletAddress: z.ZodOptional<z.ZodString>;
@@ -35,7 +36,7 @@ declare const siwe: (options: SIWEPluginOptions) => {
     }, {
       nonce: string;
     }>;
-    getNonce: import("better-call").StrictEndpoint<"/siwe/nonce" | "/siwe/get-nonce", {
+    getNonce: _$better_call0.StrictEndpoint<"/siwe/nonce" | "/siwe/get-nonce", {
       method: "POST";
       body: z.ZodObject<{
         walletAddress: z.ZodOptional<z.ZodString>;
@@ -45,7 +46,7 @@ declare const siwe: (options: SIWEPluginOptions) => {
     }, {
       nonce: string;
     }>;
-    verifySiweMessage: import("better-call").StrictEndpoint<"/siwe/verify", {
+    verifySiweMessage: _$better_call0.StrictEndpoint<"/siwe/verify", {
       method: "POST";
       body: z.ZodObject<{
         message: z.ZodString;

package/dist/plugins/test-utils/index.d.mts

@@ -1,4 +1,6 @@
 import { LoginResult, TestCookie, TestHelpers, TestUtilsOptions } from "./types.mjs";
+import * as _$_better_auth_core0 from "@better-auth/core";
+
 //#region src/plugins/test-utils/index.d.ts
 declare module "@better-auth/core" {
   interface BetterAuthPluginRegistry<AuthOptions, Options> {
@@ -48,7 +50,7 @@ declare module "@better-auth/core" {
 declare const testUtils: (options?: TestUtilsOptions) => {
   id: "test-utils";
   version: string;
-  init(ctx: import("@better-auth/core").AuthContext): {
+  init(ctx: _$_better_auth_core0.AuthContext): {
     context: {
       test: TestHelpers;
     };
@@ -68,4 +70,4 @@ declare const testUtils: (options?: TestUtilsOptions) => {
   options: TestUtilsOptions;
 };
 //#endregion
-export { type LoginResult, type TestCookie, type TestHelpers, type TestUtilsOptions, testUtils };
+export { testUtils };

package/dist/plugins/test-utils/types.d.mts

@@ -1,5 +1,4 @@
 import { Session, User } from "../../types/models.mjs";
-import "../../types/index.mjs";
 //#region src/plugins/test-utils/types.d.ts
 interface TestUtilsOptions {
   /** Capture OTPs in memory when created (doesn't prevent sending) */

package/dist/plugins/two-factor/backup-codes/index.d.mts

@@ -1,6 +1,8 @@
 import { SecretConfig } from "../../../crypto/index.mjs";
 import { UserWithTwoFactor } from "../types.mjs";
+import * as _$better_call0 from "better-call";
 import * as z from "zod";
+
 //#region src/plugins/two-factor/backup-codes/index.d.ts
 interface BackupCodeOptions {
   /**
@@ -69,7 +71,7 @@ declare const backupCode2fa: (opts: BackupCodeOptions) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#api-method-two-factor-verify-backup-code)
      */
-    verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
+    verifyBackupCode: _$better_call0.StrictEndpoint<"/two-factor/verify-backup-code", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -195,14 +197,14 @@ declare const backupCode2fa: (opts: BackupCodeOptions) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#api-method-two-factor-generate-backup-codes)
      */
-    generateBackupCodes: import("better-call").StrictEndpoint<"/two-factor/generate-backup-codes", {
+    generateBackupCodes: _$better_call0.StrictEndpoint<"/two-factor/generate-backup-codes", {
       method: "POST";
       body: z.ZodObject<{
         password: z.ZodOptional<z.ZodString>;
       }, z.core.$strip> | z.ZodObject<{
         password: z.ZodString;
       }, z.core.$strip>;
-      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -274,7 +276,7 @@ declare const backupCode2fa: (opts: BackupCodeOptions) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#api-method-two-factor-view-backup-codes)
      */
-    viewBackupCodes: import("better-call").StrictEndpoint<string, {
+    viewBackupCodes: _$better_call0.StrictEndpoint<string, {
       method: "POST";
       body: z.ZodObject<{
         userId: z.ZodCoercedString<unknown>;

package/dist/plugins/two-factor/backup-codes/index.mjs

@@ -338,4 +338,4 @@ const backupCode2fa = (opts) => {
 	};
 };
 //#endregion
-export { backupCode2fa, encodeBackupCodes, generateBackupCodes, getBackupCodes, verifyBackupCode };
+export { backupCode2fa, generateBackupCodes };

package/dist/plugins/two-factor/client.d.mts

@@ -4,6 +4,9 @@ import { TOTPOptions, totp2fa } from "./totp/index.mjs";
 import { TwoFactorOptions, TwoFactorProvider, TwoFactorTable, UserWithTwoFactor } from "./types.mjs";
 import { TWO_FACTOR_ERROR_CODES } from "./error-code.mjs";
 import { twoFactor } from "./index.mjs";
+import * as _$_better_auth_core_utils_error_codes0 from "@better-auth/core/utils/error-codes";
+import * as _$_better_fetch_fetch0 from "@better-fetch/fetch";
+
 //#region src/plugins/two-factor/client.d.ts
 declare const twoFactorClient: (options?: {
   /**
@@ -50,21 +53,21 @@ declare const twoFactorClient: (options?: {
     id: string;
     name: string;
     hooks: {
-      onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): Promise<void>;
+      onSuccess(context: _$_better_fetch_fetch0.SuccessContext<any>): Promise<void>;
     };
   }[];
   $ERROR_CODES: {
-    OTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_ENABLED">;
-    OTP_HAS_EXPIRED: import("@better-auth/core/utils/error-codes").RawError<"OTP_HAS_EXPIRED">;
-    TOTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_NOT_ENABLED">;
-    TWO_FACTOR_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TWO_FACTOR_NOT_ENABLED">;
-    BACKUP_CODES_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"BACKUP_CODES_NOT_ENABLED">;
-    INVALID_BACKUP_CODE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_BACKUP_CODE">;
-    INVALID_CODE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_CODE">;
-    TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("@better-auth/core/utils/error-codes").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
-    ACCOUNT_TEMPORARILY_LOCKED: import("@better-auth/core/utils/error-codes").RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
-    INVALID_TWO_FACTOR_COOKIE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+    OTP_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_ENABLED">;
+    OTP_HAS_EXPIRED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_HAS_EXPIRED">;
+    TOTP_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_NOT_ENABLED">;
+    TWO_FACTOR_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TWO_FACTOR_NOT_ENABLED">;
+    BACKUP_CODES_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"BACKUP_CODES_NOT_ENABLED">;
+    INVALID_BACKUP_CODE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_BACKUP_CODE">;
+    INVALID_CODE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_CODE">;
+    TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: _$_better_auth_core_utils_error_codes0.RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+    ACCOUNT_TEMPORARILY_LOCKED: _$_better_auth_core_utils_error_codes0.RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
+    INVALID_TWO_FACTOR_COOKIE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_TWO_FACTOR_COOKIE">;
   };
 };
 //#endregion
-export { type BackupCodeOptions, type OTPOptions, type TOTPOptions, TWO_FACTOR_ERROR_CODES, type TwoFactorOptions, type TwoFactorProvider, type TwoFactorTable, type UserWithTwoFactor, type backupCode2fa, type encodeBackupCodes, type generateBackupCodes, type getBackupCodes, type otp2fa, type totp2fa, twoFactorClient, type verifyBackupCode };
+export { twoFactorClient };

package/dist/plugins/two-factor/client.mjs

@@ -38,4 +38,4 @@ const twoFactorClient = (options) => {
 	};
 };
 //#endregion
-export { TWO_FACTOR_ERROR_CODES, twoFactorClient };
+export { twoFactorClient };

package/dist/plugins/two-factor/error-code.d.mts

@@ -1,15 +1,17 @@
+import * as _$_better_auth_core_utils_error_codes0 from "@better-auth/core/utils/error-codes";
+
 //#region src/plugins/two-factor/error-code.d.ts
 declare const TWO_FACTOR_ERROR_CODES: {
-  OTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_ENABLED">;
-  OTP_HAS_EXPIRED: import("@better-auth/core/utils/error-codes").RawError<"OTP_HAS_EXPIRED">;
-  TOTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_NOT_ENABLED">;
-  TWO_FACTOR_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TWO_FACTOR_NOT_ENABLED">;
-  BACKUP_CODES_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"BACKUP_CODES_NOT_ENABLED">;
-  INVALID_BACKUP_CODE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_BACKUP_CODE">;
-  INVALID_CODE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_CODE">;
-  TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("@better-auth/core/utils/error-codes").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
-  ACCOUNT_TEMPORARILY_LOCKED: import("@better-auth/core/utils/error-codes").RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
-  INVALID_TWO_FACTOR_COOKIE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+  OTP_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_ENABLED">;
+  OTP_HAS_EXPIRED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_HAS_EXPIRED">;
+  TOTP_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_NOT_ENABLED">;
+  TWO_FACTOR_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TWO_FACTOR_NOT_ENABLED">;
+  BACKUP_CODES_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"BACKUP_CODES_NOT_ENABLED">;
+  INVALID_BACKUP_CODE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_BACKUP_CODE">;
+  INVALID_CODE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_CODE">;
+  TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: _$_better_auth_core_utils_error_codes0.RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+  ACCOUNT_TEMPORARILY_LOCKED: _$_better_auth_core_utils_error_codes0.RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
+  INVALID_TWO_FACTOR_COOKIE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_TWO_FACTOR_COOKIE">;
 };
 //#endregion
 export { TWO_FACTOR_ERROR_CODES };

package/dist/plugins/two-factor/index.d.mts

@@ -4,7 +4,11 @@ import { TOTPOptions, totp2fa } from "./totp/index.mjs";
 import { TwoFactorOptions, TwoFactorProvider, TwoFactorTable, UserWithTwoFactor } from "./types.mjs";
 import { TWO_FACTOR_ERROR_CODES } from "./error-code.mjs";
 import { twoFactorClient } from "./client.mjs";
+import * as _$_better_auth_core0 from "@better-auth/core";
+import * as _$_better_auth_core_utils_error_codes0 from "@better-auth/core/utils/error-codes";
+import * as _$better_call0 from "better-call";
 import * as z from "zod";
+
 //#region src/plugins/two-factor/index.d.ts
 declare module "@better-auth/core" {
   interface BetterAuthPluginRegistry<AuthOptions, Options> {
@@ -32,7 +36,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#api-method-two-factor-enable)
      */
-    enableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/enable", {
+    enableTwoFactor: _$better_call0.StrictEndpoint<"/two-factor/enable", {
       method: "POST";
       body: z.ZodObject<{
         password: z.ZodOptional<z.ZodString>;
@@ -41,7 +45,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
         password: z.ZodString;
         issuer: z.ZodOptional<z.ZodString>;
       }, z.core.$strip>;
-      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -114,14 +118,14 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#api-method-two-factor-disable)
      */
-    disableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/disable", {
+    disableTwoFactor: _$better_call0.StrictEndpoint<"/two-factor/disable", {
       method: "POST";
       body: z.ZodObject<{
         password: z.ZodOptional<z.ZodString>;
       }, z.core.$strip> | z.ZodObject<{
         password: z.ZodString;
       }, z.core.$strip>;
-      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -170,7 +174,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     }, {
       status: boolean;
     }>;
-    verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
+    verifyBackupCode: _$better_call0.StrictEndpoint<"/two-factor/verify-backup-code", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -281,14 +285,14 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
         image?: string | null | undefined;
       }) | UserWithTwoFactor;
     }>;
-    generateBackupCodes: import("better-call").StrictEndpoint<"/two-factor/generate-backup-codes", {
+    generateBackupCodes: _$better_call0.StrictEndpoint<"/two-factor/generate-backup-codes", {
       method: "POST";
       body: z.ZodObject<{
         password: z.ZodOptional<z.ZodString>;
       }, z.core.$strip> | z.ZodObject<{
         password: z.ZodString;
       }, z.core.$strip>;
-      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -347,7 +351,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
       status: boolean;
       backupCodes: string[];
     }>;
-    viewBackupCodes: import("better-call").StrictEndpoint<string, {
+    viewBackupCodes: _$better_call0.StrictEndpoint<string, {
       method: "POST";
       body: z.ZodObject<{
         userId: z.ZodCoercedString<unknown>;
@@ -356,7 +360,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
       status: boolean;
       backupCodes: string[];
     }>;
-    sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
+    sendTwoFactorOTP: _$better_call0.StrictEndpoint<"/two-factor/send-otp", {
       method: "POST";
       body: z.ZodOptional<z.ZodObject<{
         trustDevice: z.ZodOptional<z.ZodBoolean>;
@@ -387,7 +391,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     }, {
       status: boolean;
     }>;
-    verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
+    verifyTwoFactorOTP: _$better_call0.StrictEndpoint<"/two-factor/verify-otp", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -476,7 +480,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
         image?: string | null | undefined;
       };
     }>;
-    generateTOTP: import("better-call").StrictEndpoint<string, {
+    generateTOTP: _$better_call0.StrictEndpoint<string, {
       method: "POST";
       body: z.ZodObject<{
         secret: z.ZodString;
@@ -507,9 +511,9 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     }, {
       code: string;
     }>;
-    getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
+    getTOTPURI: _$better_call0.StrictEndpoint<"/two-factor/get-totp-uri", {
       method: "POST";
-      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -563,7 +567,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     }, {
       totpURI: string;
     }>;
-    verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
+    verifyTOTP: _$better_call0.StrictEndpoint<"/two-factor/verify-totp", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -611,8 +615,8 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
   options: NoInfer<O>;
   hooks: {
     after: {
-      matcher(context: import("@better-auth/core").HookEndpointContext): boolean;
-      handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+      matcher(context: _$_better_auth_core0.HookEndpointContext): boolean;
+      handler: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
         twoFactorRedirect: boolean;
         twoFactorMethods: string[];
       } | undefined>>;
@@ -680,17 +684,17 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     max: number;
   }[];
   $ERROR_CODES: {
-    OTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_ENABLED">;
-    OTP_HAS_EXPIRED: import("@better-auth/core/utils/error-codes").RawError<"OTP_HAS_EXPIRED">;
-    TOTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_NOT_ENABLED">;
-    TWO_FACTOR_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TWO_FACTOR_NOT_ENABLED">;
-    BACKUP_CODES_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"BACKUP_CODES_NOT_ENABLED">;
-    INVALID_BACKUP_CODE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_BACKUP_CODE">;
-    INVALID_CODE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_CODE">;
-    TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("@better-auth/core/utils/error-codes").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
-    ACCOUNT_TEMPORARILY_LOCKED: import("@better-auth/core/utils/error-codes").RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
-    INVALID_TWO_FACTOR_COOKIE: import("@better-auth/core/utils/error-codes").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+    OTP_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_ENABLED">;
+    OTP_HAS_EXPIRED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_HAS_EXPIRED">;
+    TOTP_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_NOT_ENABLED">;
+    TWO_FACTOR_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TWO_FACTOR_NOT_ENABLED">;
+    BACKUP_CODES_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"BACKUP_CODES_NOT_ENABLED">;
+    INVALID_BACKUP_CODE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_BACKUP_CODE">;
+    INVALID_CODE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_CODE">;
+    TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: _$_better_auth_core_utils_error_codes0.RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+    ACCOUNT_TEMPORARILY_LOCKED: _$_better_auth_core_utils_error_codes0.RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
+    INVALID_TWO_FACTOR_COOKIE: _$_better_auth_core_utils_error_codes0.RawError<"INVALID_TWO_FACTOR_COOKIE">;
   };
 };
 //#endregion
-export { type BackupCodeOptions, type OTPOptions, type TOTPOptions, TWO_FACTOR_ERROR_CODES, TwoFactorOptions, TwoFactorProvider, TwoFactorTable, UserWithTwoFactor, type backupCode2fa, type encodeBackupCodes, type generateBackupCodes, type getBackupCodes, type otp2fa, type totp2fa, twoFactor, twoFactorClient, type verifyBackupCode };
+export { BackupCodeOptions, OTPOptions, TOTPOptions, TWO_FACTOR_ERROR_CODES, TwoFactorOptions, TwoFactorProvider, TwoFactorTable, UserWithTwoFactor, backupCode2fa, encodeBackupCodes, generateBackupCodes, getBackupCodes, otp2fa, totp2fa, twoFactor, twoFactorClient, verifyBackupCode };

package/dist/plugins/two-factor/otp/index.d.mts

@@ -1,6 +1,8 @@
 import { UserWithTwoFactor } from "../types.mjs";
 import { Awaitable, GenericEndpointContext } from "@better-auth/core";
+import * as _$better_call0 from "better-call";
 import * as z from "zod";
+
 //#region src/plugins/two-factor/otp/index.d.ts
 interface OTPOptions {
   /**
@@ -73,7 +75,7 @@ declare const otp2fa: (options?: OTPOptions | undefined) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#api-method-two-factor-send-otp)
      */
-    sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
+    sendTwoFactorOTP: _$better_call0.StrictEndpoint<"/two-factor/send-otp", {
       method: "POST";
       body: z.ZodOptional<z.ZodObject<{
         trustDevice: z.ZodOptional<z.ZodBoolean>;
@@ -119,7 +121,7 @@ declare const otp2fa: (options?: OTPOptions | undefined) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#api-method-two-factor-verify-otp)
      */
-    verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
+    verifyTwoFactorOTP: _$better_call0.StrictEndpoint<"/two-factor/verify-otp", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;

package/dist/plugins/two-factor/totp/index.d.mts

@@ -1,6 +1,8 @@
 import { BackupCodeOptions } from "../backup-codes/index.mjs";
 import { UserWithTwoFactor } from "../types.mjs";
+import * as _$better_call0 from "better-call";
 import * as z from "zod";
+
 //#region src/plugins/two-factor/totp/index.d.ts
 type TOTPOptions = {
   /**
@@ -50,7 +52,7 @@ declare const totp2fa: (options?: TOTPOptions | undefined) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#totp)
      */
-    generateTOTP: import("better-call").StrictEndpoint<string, {
+    generateTOTP: _$better_call0.StrictEndpoint<string, {
       method: "POST";
       body: z.ZodObject<{
         secret: z.ZodString;
@@ -96,9 +98,9 @@ declare const totp2fa: (options?: TOTPOptions | undefined) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#getting-totp-uri)
      */
-    getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
+    getTOTPURI: _$better_call0.StrictEndpoint<"/two-factor/get-totp-uri", {
       method: "POST";
-      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -167,7 +169,7 @@ declare const totp2fa: (options?: TOTPOptions | undefined) => {
      *
      * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/2fa#verifying-totp)
      */
-    verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
+    verifyTOTP: _$better_call0.StrictEndpoint<"/two-factor/verify-totp", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;

package/dist/plugins/two-factor/types.d.mts

@@ -1,11 +1,11 @@
 import { User } from "../../types/models.mjs";
 import { InferOptionSchema } from "../../types/plugins.mjs";
-import "../../types/index.mjs";
 import { BackupCodeOptions } from "./backup-codes/index.mjs";
 import { OTPOptions } from "./otp/index.mjs";
 import { schema } from "./schema.mjs";
 import { TOTPOptions } from "./totp/index.mjs";
 import { BetterAuthPlugin, LiteralString } from "@better-auth/core";
+
 //#region src/plugins/two-factor/types.d.ts
 interface TwoFactorOptions {
   /**