better-auth 1.7.11 → 1.7.13

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

@@ -1,10 +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 {
+export interface BackupCodeOptions {
   /**
    * The amount of backup codes to generate
    *
@@ -36,12 +34,12 @@ interface BackupCodeOptions {
    */
   allowPasswordless?: boolean | undefined;
 }
-declare function encodeBackupCodes(codes: string[], secret: string | SecretConfig, options?: BackupCodeOptions | undefined): Promise<string>;
-declare function generateBackupCodes(secret: string | SecretConfig, options?: BackupCodeOptions | undefined): Promise<{
+export declare function encodeBackupCodes(codes: string[], secret: string | SecretConfig, options?: BackupCodeOptions | undefined): Promise<string>;
+export declare function generateBackupCodes(secret: string | SecretConfig, options?: BackupCodeOptions | undefined): Promise<{
   backupCodes: string[];
   encryptedBackupCodes: string;
 }>;
-declare function verifyBackupCode(data: {
+export declare function verifyBackupCode(data: {
   backupCodes: string;
   code: string;
 }, key: string | SecretConfig, options?: BackupCodeOptions | undefined): Promise<{
@@ -51,8 +49,8 @@ declare function verifyBackupCode(data: {
   status: boolean;
   updated: string[];
 }>;
-declare function getBackupCodes(backupCodes: string, key: string | SecretConfig, options?: BackupCodeOptions | undefined): Promise<string[] | null>;
-declare const backupCode2fa: (opts: BackupCodeOptions) => {
+export declare function getBackupCodes(backupCodes: string, key: string | SecretConfig, options?: BackupCodeOptions | undefined): Promise<string[] | null>;
+export declare const backupCode2fa: (opts: BackupCodeOptions) => {
   id: "backup_code";
   version: string;
   endpoints: {
@@ -71,7 +69,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: _$better_call0.StrictEndpoint<"/two-factor/verify-backup-code", {
+    verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -197,14 +195,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: _$better_call0.StrictEndpoint<"/two-factor/generate-backup-codes", {
+    generateBackupCodes: import("better-call").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: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
+      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -276,7 +274,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: _$better_call0.StrictEndpoint<string, {
+    viewBackupCodes: import("better-call").StrictEndpoint<string, {
       method: "POST";
       body: z.ZodObject<{
         userId: z.ZodCoercedString<unknown>;
@@ -287,5 +285,4 @@ declare const backupCode2fa: (opts: BackupCodeOptions) => {
     }>;
   };
 };
-//#endregion
-export { BackupCodeOptions, backupCode2fa, encodeBackupCodes, generateBackupCodes, getBackupCodes, verifyBackupCode };
+//#endregion

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

@@ -42,11 +42,17 @@ async function verifyBackupCode(data, key, options) {
 	};
 }
 async function getBackupCodes(backupCodes, key, options) {
-	if (options?.storeBackupCodes === "encrypted") return safeJSONParse(await symmetricDecrypt({
-		key,
-		data: backupCodes
-	}));
-	if (typeof options?.storeBackupCodes === "object" && "decrypt" in options?.storeBackupCodes) return safeJSONParse(await options?.storeBackupCodes.decrypt(backupCodes));
+	if (options?.storeBackupCodes === "encrypted") {
+		const decrypted = await symmetricDecrypt({
+			key,
+			data: backupCodes
+		});
+		return safeJSONParse(decrypted);
+	}
+	if (typeof options?.storeBackupCodes === "object" && "decrypt" in options?.storeBackupCodes) {
+		const decrypted = await options?.storeBackupCodes.decrypt(backupCodes);
+		return safeJSONParse(decrypted);
+	}
 	return safeJSONParse(backupCodes);
 }
 const verifyBackupCodeBodySchema = z.object({
@@ -338,4 +344,4 @@ const backupCode2fa = (opts) => {
 	};
 };
 //#endregion
-export { backupCode2fa, generateBackupCodes };
+export { backupCode2fa, encodeBackupCodes, generateBackupCodes, getBackupCodes, verifyBackupCode };

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

@@ -4,11 +4,8 @@ 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?: {
+export declare const twoFactorClient: (options?: {
   /**
    * the page to redirect if a user needs to verify
    * their two factor
@@ -53,24 +50,24 @@ declare const twoFactorClient: (options?: {
     id: string;
     name: string;
     hooks: {
-      onSuccess(context: _$_better_fetch_fetch0.SuccessContext<any>): Promise<void>;
+      onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): Promise<void>;
     };
   }[];
   $ERROR_CODES: {
-    OTP_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_ENABLED">;
-    OTP_NOT_CONFIGURED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_CONFIGURED">;
-    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">;
-    TOTP_ALREADY_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_ALREADY_ENABLED">;
-    TOTP_NOT_CONFIGURED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_NOT_CONFIGURED">;
-    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">;
+    OTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_ENABLED">;
+    OTP_NOT_CONFIGURED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_CONFIGURED">;
+    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">;
+    TOTP_ALREADY_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_ALREADY_ENABLED">;
+    TOTP_NOT_CONFIGURED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_NOT_CONFIGURED">;
+    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">;
   };
 };
 //#endregion
-export { twoFactorClient };
+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, type verifyBackupCode };

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

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

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

@@ -1,6 +1,6 @@
 //#region src/plugins/two-factor/constant.ts
 const TWO_FACTOR_COOKIE_NAME = "two_factor";
 const TRUST_DEVICE_COOKIE_NAME = "trust_device";
-const TRUST_DEVICE_COOKIE_MAX_AGE = 720 * 60 * 60;
+const TRUST_DEVICE_COOKIE_MAX_AGE = 2592e3;
 //#endregion
 export { TRUST_DEVICE_COOKIE_MAX_AGE, TRUST_DEVICE_COOKIE_NAME, TWO_FACTOR_COOKIE_NAME };

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

@@ -1,20 +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: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_ENABLED">;
-  OTP_NOT_CONFIGURED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_CONFIGURED">;
-  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">;
-  TOTP_ALREADY_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_ALREADY_ENABLED">;
-  TOTP_NOT_CONFIGURED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_NOT_CONFIGURED">;
-  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">;
+export declare const TWO_FACTOR_ERROR_CODES: {
+  OTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_ENABLED">;
+  OTP_NOT_CONFIGURED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_CONFIGURED">;
+  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">;
+  TOTP_ALREADY_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_ALREADY_ENABLED">;
+  TOTP_NOT_CONFIGURED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_NOT_CONFIGURED">;
+  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">;
 };
-//#endregion
-export { TWO_FACTOR_ERROR_CODES };
+//#endregion

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

@@ -4,11 +4,7 @@ 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> {
@@ -17,7 +13,7 @@ declare module "@better-auth/core" {
     };
   }
 }
-declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
+export declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
   id: "two-factor";
   version: string;
   endpoints: {
@@ -36,7 +32,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: _$better_call0.StrictEndpoint<"/two-factor/enable", {
+    enableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/enable", {
       method: "POST";
       body: z.ZodObject<{
         password: z.ZodOptional<z.ZodString>;
@@ -53,7 +49,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
         }>>;
         issuer: z.ZodOptional<z.ZodString>;
       }, z.core.$strip>;
-      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
+      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -135,14 +131,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: _$better_call0.StrictEndpoint<"/two-factor/disable", {
+    disableTwoFactor: import("better-call").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: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
+      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -191,7 +187,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     }, {
       status: boolean;
     }>;
-    verifyBackupCode: _$better_call0.StrictEndpoint<"/two-factor/verify-backup-code", {
+    verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -302,14 +298,14 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
         image?: string | null | undefined;
       }) | UserWithTwoFactor;
     }>;
-    generateBackupCodes: _$better_call0.StrictEndpoint<"/two-factor/generate-backup-codes", {
+    generateBackupCodes: import("better-call").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: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
+      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -368,7 +364,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
       status: boolean;
       backupCodes: string[];
     }>;
-    viewBackupCodes: _$better_call0.StrictEndpoint<string, {
+    viewBackupCodes: import("better-call").StrictEndpoint<string, {
       method: "POST";
       body: z.ZodObject<{
         userId: z.ZodCoercedString<unknown>;
@@ -377,7 +373,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
       status: boolean;
       backupCodes: string[];
     }>;
-    sendTwoFactorOTP: _$better_call0.StrictEndpoint<"/two-factor/send-otp", {
+    sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
       method: "POST";
       body: z.ZodOptional<z.ZodObject<{
         trustDevice: z.ZodOptional<z.ZodBoolean>;
@@ -408,7 +404,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     }, {
       status: boolean;
     }>;
-    verifyTwoFactorOTP: _$better_call0.StrictEndpoint<"/two-factor/verify-otp", {
+    verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -497,7 +493,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
         image?: string | null | undefined;
       };
     }>;
-    generateTOTP: _$better_call0.StrictEndpoint<string, {
+    generateTOTP: import("better-call").StrictEndpoint<string, {
       method: "POST";
       body: z.ZodObject<{
         secret: z.ZodString;
@@ -528,9 +524,9 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     }, {
       code: string;
     }>;
-    getTOTPURI: _$better_call0.StrictEndpoint<"/two-factor/get-totp-uri", {
+    getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
       method: "POST";
-      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
+      use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -584,7 +580,7 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     }, {
       totpURI: string;
     }>;
-    verifyTOTP: _$better_call0.StrictEndpoint<"/two-factor/verify-totp", {
+    verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -632,8 +628,8 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
   options: NoInfer<O>;
   hooks: {
     after: {
-      matcher(context: _$_better_auth_core0.HookEndpointContext): boolean;
-      handler: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
+      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<{
         twoFactorRedirect: boolean;
         twoFactorMethods: string[];
       } | undefined>>;
@@ -701,20 +697,20 @@ declare const twoFactor: <O extends TwoFactorOptions>(options?: O) => {
     max: number;
   }[];
   $ERROR_CODES: {
-    OTP_NOT_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_ENABLED">;
-    OTP_NOT_CONFIGURED: _$_better_auth_core_utils_error_codes0.RawError<"OTP_NOT_CONFIGURED">;
-    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">;
-    TOTP_ALREADY_ENABLED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_ALREADY_ENABLED">;
-    TOTP_NOT_CONFIGURED: _$_better_auth_core_utils_error_codes0.RawError<"TOTP_NOT_CONFIGURED">;
-    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">;
+    OTP_NOT_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_ENABLED">;
+    OTP_NOT_CONFIGURED: import("@better-auth/core/utils/error-codes").RawError<"OTP_NOT_CONFIGURED">;
+    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">;
+    TOTP_ALREADY_ENABLED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_ALREADY_ENABLED">;
+    TOTP_NOT_CONFIGURED: import("@better-auth/core/utils/error-codes").RawError<"TOTP_NOT_CONFIGURED">;
+    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">;
   };
 };
 //#endregion
-export { BackupCodeOptions, OTPOptions, TOTPOptions, TWO_FACTOR_ERROR_CODES, TwoFactorOptions, TwoFactorProvider, TwoFactorTable, UserWithTwoFactor, backupCode2fa, encodeBackupCodes, generateBackupCodes, getBackupCodes, otp2fa, totp2fa, twoFactor, twoFactorClient, verifyBackupCode };
+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, twoFactorClient, type verifyBackupCode };

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

@@ -115,8 +115,9 @@ const twoFactor = (options) => {
 				if (method === "totp" && options?.totpOptions?.disable) throw APIError.from("BAD_REQUEST", TWO_FACTOR_ERROR_CODES.TOTP_NOT_CONFIGURED);
 				if (method === "otp") {
 					const updatedUser = await ctx.context.internalAdapter.updateUser(user.id, { twoFactorEnabled: true });
+					const newSession = await ctx.context.internalAdapter.createSession(updatedUser.id, false, ctx.context.session.session);
 					await setSessionCookie(ctx, {
-						session: await ctx.context.internalAdapter.createSession(updatedUser.id, false, ctx.context.session.session),
+						session: newSession,
 						user: updatedUser
 					});
 					await ctx.context.internalAdapter.deleteSession(ctx.context.session.session.token);
@@ -138,8 +139,9 @@ const twoFactor = (options) => {
 				});
 				if (options?.skipVerificationOnEnable) {
 					const updatedUser = await ctx.context.internalAdapter.updateUser(user.id, { twoFactorEnabled: true });
+					const newSession = await ctx.context.internalAdapter.createSession(updatedUser.id, false, ctx.context.session.session);
 					await setSessionCookie(ctx, {
-						session: await ctx.context.internalAdapter.createSession(updatedUser.id, false, ctx.context.session.session),
+						session: newSession,
 						user: updatedUser
 					});
 					await ctx.context.internalAdapter.deleteSession(ctx.context.session.session.token);
@@ -222,11 +224,12 @@ const twoFactor = (options) => {
 						value: updatedUser.id
 					}]
 				});
+				const newSession = await ctx.context.internalAdapter.createSession(updatedUser.id, false, ctx.context.session.session);
 				/**
 				* Update the session cookie with the new user data
 				*/
 				await setSessionCookie(ctx, {
-					session: await ctx.context.internalAdapter.createSession(updatedUser.id, false, ctx.context.session.session),
+					session: newSession,
 					user: updatedUser
 				});
 				await ctx.context.internalAdapter.deleteSession(ctx.context.session.session.token);

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

@@ -1,10 +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 {
+export interface OTPOptions {
   /**
    * How long the opt will be valid for in
    * minutes
@@ -56,7 +54,7 @@ interface OTPOptions {
 /**
  * The otp adapter is created from the totp adapter.
  */
-declare const otp2fa: (options?: OTPOptions | undefined) => {
+export declare const otp2fa: (options?: OTPOptions | undefined) => {
   id: "otp";
   version: string;
   endpoints: {
@@ -75,7 +73,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: _$better_call0.StrictEndpoint<"/two-factor/send-otp", {
+    sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
       method: "POST";
       body: z.ZodOptional<z.ZodObject<{
         trustDevice: z.ZodOptional<z.ZodBoolean>;
@@ -121,7 +119,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: _$better_call0.StrictEndpoint<"/two-factor/verify-otp", {
+    verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
       method: "POST";
       body: z.ZodObject<{
         code: z.ZodString;
@@ -212,5 +210,4 @@ declare const otp2fa: (options?: OTPOptions | undefined) => {
     }>;
   };
 };
-//#endregion
-export { OTPOptions, otp2fa };
+//#endregion